Home · All Classes · All Namespaces · Modules · Functions · Files

cli-channel.h

00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
00003  *
00004  * This file can be distributed under the same terms as the specification from
00005  * which it was generated.
00006  */
00007 
00008 #ifndef IN_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011 
00012 #include <TelepathyQt4/Types>
00013 
00014 #include <QtGlobal>
00015 
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019 
00020 #include <QDBusPendingReply>
00021 
00022 #include <TelepathyQt4/AbstractInterface>
00023 #include <TelepathyQt4/DBusProxy>
00024 #include <TelepathyQt4/Global>
00025 
00026 namespace Tp
00027 {
00028 class PendingVariant;
00029 class PendingOperation;
00030 }
00031 
00032 namespace Tp
00033 {
00034 namespace Client
00035 {
00036 
00044 class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
00045 {
00046     Q_OBJECT
00047 
00048 public:
00055     static inline QLatin1String staticInterfaceName()
00056     {
00057         return QLatin1String("org.freedesktop.Telepathy.Channel");
00058     }
00059 
00067     ChannelInterface(
00068         const QString& busName,
00069         const QString& objectPath,
00070         QObject* parent = 0
00071     );
00072 
00081     ChannelInterface(
00082         const QDBusConnection& connection,
00083         const QString& busName,
00084         const QString& objectPath,
00085         QObject* parent = 0
00086     );
00087 
00094     ChannelInterface(Tp::DBusProxy *proxy);
00095 
00124     inline Tp::PendingVariant *requestPropertyChannelType() const
00125     {
00126         return internalRequestProperty(QLatin1String("ChannelType"));
00127     }
00128 
00160     inline Tp::PendingVariant *requestPropertyInterfaces() const
00161     {
00162         return internalRequestProperty(QLatin1String("Interfaces"));
00163     }
00164 
00207     inline Tp::PendingVariant *requestPropertyTargetHandle() const
00208     {
00209         return internalRequestProperty(QLatin1String("TargetHandle"));
00210     }
00211 
00263     inline Tp::PendingVariant *requestPropertyTargetID() const
00264     {
00265         return internalRequestProperty(QLatin1String("TargetID"));
00266     }
00267 
00285     inline Tp::PendingVariant *requestPropertyTargetHandleType() const
00286     {
00287         return internalRequestProperty(QLatin1String("TargetHandleType"));
00288     }
00289 
00356     inline Tp::PendingVariant *requestPropertyRequested() const
00357     {
00358         return internalRequestProperty(QLatin1String("Requested"));
00359     }
00360 
00420     inline Tp::PendingVariant *requestPropertyInitiatorHandle() const
00421     {
00422         return internalRequestProperty(QLatin1String("InitiatorHandle"));
00423     }
00424 
00457     inline Tp::PendingVariant *requestPropertyInitiatorID() const
00458     {
00459         return internalRequestProperty(QLatin1String("InitiatorID"));
00460     }
00461 
00468     Tp::PendingVariantMap *requestAllProperties() const
00469     {
00470         return internalRequestAllProperties();
00471     }
00472 
00473 public Q_SLOTS:
00488     inline QDBusPendingReply<> Close(int timeout = -1)
00489     {
00490         if (!invalidationReason().isEmpty()) {
00491             return QDBusPendingReply<>(QDBusMessage::createError(
00492                 invalidationReason(),
00493                 invalidationMessage()
00494             ));
00495         }
00496 
00497         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00498                 this->staticInterfaceName(), QLatin1String("Close"));
00499         return this->connection().asyncCall(callMessage, timeout);
00500     }
00501 
00519     inline QDBusPendingReply<QString> GetChannelType(int timeout = -1)
00520     {
00521         if (!invalidationReason().isEmpty()) {
00522             return QDBusPendingReply<QString>(QDBusMessage::createError(
00523                 invalidationReason(),
00524                 invalidationMessage()
00525             ));
00526         }
00527 
00528         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00529                 this->staticInterfaceName(), QLatin1String("GetChannelType"));
00530         return this->connection().asyncCall(callMessage, timeout);
00531     }
00532 
00556     inline QDBusPendingReply<uint, uint> GetHandle(int timeout = -1)
00557     {
00558         if (!invalidationReason().isEmpty()) {
00559             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00560                 invalidationReason(),
00561                 invalidationMessage()
00562             ));
00563         }
00564 
00565         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00566                 this->staticInterfaceName(), QLatin1String("GetHandle"));
00567         return this->connection().asyncCall(callMessage, timeout);
00568     }
00569 
00587     inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00588     {
00589         if (!invalidationReason().isEmpty()) {
00590             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00591                 invalidationReason(),
00592                 invalidationMessage()
00593             ));
00594         }
00595 
00596         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00597                 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00598         return this->connection().asyncCall(callMessage, timeout);
00599     }
00600 
00601 Q_SIGNALS:
00609     void Closed();
00610 
00611 protected:
00612     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00613 };
00614 
00622 class TELEPATHY_QT4_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
00623 {
00624     Q_OBJECT
00625 
00626 public:
00633     static inline QLatin1String staticInterfaceName()
00634     {
00635         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Anonymity");
00636     }
00637 
00645     ChannelInterfaceAnonymityInterface(
00646         const QString& busName,
00647         const QString& objectPath,
00648         QObject* parent = 0
00649     );
00650 
00659     ChannelInterfaceAnonymityInterface(
00660         const QDBusConnection& connection,
00661         const QString& busName,
00662         const QString& objectPath,
00663         QObject* parent = 0
00664     );
00665 
00672     ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00673 
00681     explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);
00682 
00690     ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00691 
00702     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
00703     {
00704         return internalRequestProperty(QLatin1String("AnonymityModes"));
00705     }
00706 
00717     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
00718     {
00719         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
00720     }
00721 
00741     inline Tp::PendingVariant *requestPropertyAnonymousID() const
00742     {
00743         return internalRequestProperty(QLatin1String("AnonymousID"));
00744     }
00745 
00752     Tp::PendingVariantMap *requestAllProperties() const
00753     {
00754         return internalRequestAllProperties();
00755     }
00756 
00757 protected:
00758     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00759 };
00760 
00768 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00769 {
00770     Q_OBJECT
00771 
00772 public:
00779     static inline QLatin1String staticInterfaceName()
00780     {
00781         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.CallState");
00782     }
00783 
00791     ChannelInterfaceCallStateInterface(
00792         const QString& busName,
00793         const QString& objectPath,
00794         QObject* parent = 0
00795     );
00796 
00805     ChannelInterfaceCallStateInterface(
00806         const QDBusConnection& connection,
00807         const QString& busName,
00808         const QString& objectPath,
00809         QObject* parent = 0
00810     );
00811 
00818     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00819 
00827     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00828 
00836     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00837 
00844     Tp::PendingVariantMap *requestAllProperties() const
00845     {
00846         return internalRequestAllProperties();
00847     }
00848 
00849 public Q_SLOTS:
00865     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates(int timeout = -1)
00866     {
00867         if (!invalidationReason().isEmpty()) {
00868             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00869                 invalidationReason(),
00870                 invalidationMessage()
00871             ));
00872         }
00873 
00874         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00875                 this->staticInterfaceName(), QLatin1String("GetCallStates"));
00876         return this->connection().asyncCall(callMessage, timeout);
00877     }
00878 
00879 Q_SIGNALS:
00893     void CallStateChanged(uint contact, uint state);
00894 
00895 protected:
00896     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00897 };
00898 
00906 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00907 {
00908     Q_OBJECT
00909 
00910 public:
00917     static inline QLatin1String staticInterfaceName()
00918     {
00919         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ChatState");
00920     }
00921 
00929     ChannelInterfaceChatStateInterface(
00930         const QString& busName,
00931         const QString& objectPath,
00932         QObject* parent = 0
00933     );
00934 
00943     ChannelInterfaceChatStateInterface(
00944         const QDBusConnection& connection,
00945         const QString& busName,
00946         const QString& objectPath,
00947         QObject* parent = 0
00948     );
00949 
00956     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00957 
00965     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00966 
00974     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00975 
01009     inline Tp::PendingVariant *requestPropertyChatStates() const
01010     {
01011         return internalRequestProperty(QLatin1String("ChatStates"));
01012     }
01013 
01020     Tp::PendingVariantMap *requestAllProperties() const
01021     {
01022         return internalRequestAllProperties();
01023     }
01024 
01025 public Q_SLOTS:
01041     inline QDBusPendingReply<> SetChatState(uint state, int timeout = -1)
01042     {
01043         if (!invalidationReason().isEmpty()) {
01044             return QDBusPendingReply<>(QDBusMessage::createError(
01045                 invalidationReason(),
01046                 invalidationMessage()
01047             ));
01048         }
01049 
01050         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01051                 this->staticInterfaceName(), QLatin1String("SetChatState"));
01052         callMessage << QVariant::fromValue(state);
01053         return this->connection().asyncCall(callMessage, timeout);
01054     }
01055 
01056 Q_SIGNALS:
01071     void ChatStateChanged(uint contact, uint state);
01072 
01073 protected:
01074     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01075 };
01076 
01084 class TELEPATHY_QT4_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
01085 {
01086     Q_OBJECT
01087 
01088 public:
01095     static inline QLatin1String staticInterfaceName()
01096     {
01097         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Conference");
01098     }
01099 
01107     ChannelInterfaceConferenceInterface(
01108         const QString& busName,
01109         const QString& objectPath,
01110         QObject* parent = 0
01111     );
01112 
01121     ChannelInterfaceConferenceInterface(
01122         const QDBusConnection& connection,
01123         const QString& busName,
01124         const QString& objectPath,
01125         QObject* parent = 0
01126     );
01127 
01134     ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
01135 
01143     explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
01144 
01152     ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01153 
01180     inline Tp::PendingVariant *requestPropertyChannels() const
01181     {
01182         return internalRequestProperty(QLatin1String("Channels"));
01183     }
01184 
01244     inline Tp::PendingVariant *requestPropertyInitialChannels() const
01245     {
01246         return internalRequestProperty(QLatin1String("InitialChannels"));
01247     }
01248 
01320     inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
01321     {
01322         return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
01323     }
01324 
01347     inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
01348     {
01349         return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
01350     }
01351 
01377     inline Tp::PendingVariant *requestPropertyInvitationMessage() const
01378     {
01379         return internalRequestProperty(QLatin1String("InvitationMessage"));
01380     }
01381 
01445     inline Tp::PendingVariant *requestPropertyOriginalChannels() const
01446     {
01447         return internalRequestProperty(QLatin1String("OriginalChannels"));
01448     }
01449 
01456     Tp::PendingVariantMap *requestAllProperties() const
01457     {
01458         return internalRequestAllProperties();
01459     }
01460 
01461 Q_SIGNALS:
01483     void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01484 
01505     void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01506 
01507 protected:
01508     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01509 };
01510 
01518 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01519 {
01520     Q_OBJECT
01521 
01522 public:
01529     static inline QLatin1String staticInterfaceName()
01530     {
01531         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
01532     }
01533 
01541     ChannelInterfaceDTMFInterface(
01542         const QString& busName,
01543         const QString& objectPath,
01544         QObject* parent = 0
01545     );
01546 
01555     ChannelInterfaceDTMFInterface(
01556         const QDBusConnection& connection,
01557         const QString& busName,
01558         const QString& objectPath,
01559         QObject* parent = 0
01560     );
01561 
01568     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
01569 
01577     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
01578 
01586     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01587 
01599     inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
01600     {
01601         return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
01602     }
01603 
01616     inline Tp::PendingVariant *requestPropertyInitialTones() const
01617     {
01618         return internalRequestProperty(QLatin1String("InitialTones"));
01619     }
01620 
01636     inline Tp::PendingVariant *requestPropertyDeferredTones() const
01637     {
01638         return internalRequestProperty(QLatin1String("DeferredTones"));
01639     }
01640 
01647     Tp::PendingVariantMap *requestAllProperties() const
01648     {
01649         return internalRequestAllProperties();
01650     }
01651 
01652 public Q_SLOTS:
01683     inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
01684     {
01685         if (!invalidationReason().isEmpty()) {
01686             return QDBusPendingReply<>(QDBusMessage::createError(
01687                 invalidationReason(),
01688                 invalidationMessage()
01689             ));
01690         }
01691 
01692         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01693                 this->staticInterfaceName(), QLatin1String("StartTone"));
01694         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01695         return this->connection().asyncCall(callMessage, timeout);
01696     }
01697 
01720     inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
01721     {
01722         if (!invalidationReason().isEmpty()) {
01723             return QDBusPendingReply<>(QDBusMessage::createError(
01724                 invalidationReason(),
01725                 invalidationMessage()
01726             ));
01727         }
01728 
01729         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01730                 this->staticInterfaceName(), QLatin1String("StopTone"));
01731         callMessage << QVariant::fromValue(streamID);
01732         return this->connection().asyncCall(callMessage, timeout);
01733     }
01734 
01778     inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
01779     {
01780         if (!invalidationReason().isEmpty()) {
01781             return QDBusPendingReply<>(QDBusMessage::createError(
01782                 invalidationReason(),
01783                 invalidationMessage()
01784             ));
01785         }
01786 
01787         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01788                 this->staticInterfaceName(), QLatin1String("MultipleTones"));
01789         callMessage << QVariant::fromValue(tones);
01790         return this->connection().asyncCall(callMessage, timeout);
01791     }
01792 
01793 Q_SIGNALS:
01819     void TonesDeferred(const QString& tones);
01820 
01835     void SendingTones(const QString& tones);
01836 
01846     void StoppedTones(bool cancelled);
01847 
01848 protected:
01849     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01850 };
01851 
01859 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
01860 {
01861     Q_OBJECT
01862 
01863 public:
01870     static inline QLatin1String staticInterfaceName()
01871     {
01872         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
01873     }
01874 
01882     ChannelInterfaceGroupInterface(
01883         const QString& busName,
01884         const QString& objectPath,
01885         QObject* parent = 0
01886     );
01887 
01896     ChannelInterfaceGroupInterface(
01897         const QDBusConnection& connection,
01898         const QString& busName,
01899         const QString& objectPath,
01900         QObject* parent = 0
01901     );
01902 
01909     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01910 
01918     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01919 
01927     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01928 
01941     inline Tp::PendingVariant *requestPropertyGroupFlags() const
01942     {
01943         return internalRequestProperty(QLatin1String("GroupFlags"));
01944     }
01945 
01961     inline Tp::PendingVariant *requestPropertyHandleOwners() const
01962     {
01963         return internalRequestProperty(QLatin1String("HandleOwners"));
01964     }
01965 
01976     inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
01977     {
01978         return internalRequestProperty(QLatin1String("LocalPendingMembers"));
01979     }
01980 
01990     inline Tp::PendingVariant *requestPropertyMembers() const
01991     {
01992         return internalRequestProperty(QLatin1String("Members"));
01993     }
01994 
02005     inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
02006     {
02007         return internalRequestProperty(QLatin1String("RemotePendingMembers"));
02008     }
02009 
02024     inline Tp::PendingVariant *requestPropertySelfHandle() const
02025     {
02026         return internalRequestProperty(QLatin1String("SelfHandle"));
02027     }
02028 
02035     Tp::PendingVariantMap *requestAllProperties() const
02036     {
02037         return internalRequestAllProperties();
02038     }
02039 
02040 public Q_SLOTS:
02069     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02070     {
02071         if (!invalidationReason().isEmpty()) {
02072             return QDBusPendingReply<>(QDBusMessage::createError(
02073                 invalidationReason(),
02074                 invalidationMessage()
02075             ));
02076         }
02077 
02078         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02079                 this->staticInterfaceName(), QLatin1String("AddMembers"));
02080         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02081         return this->connection().asyncCall(callMessage, timeout);
02082     }
02083 
02106     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
02107     {
02108         if (!invalidationReason().isEmpty()) {
02109             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02110                 invalidationReason(),
02111                 invalidationMessage()
02112             ));
02113         }
02114 
02115         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02116                 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
02117         return this->connection().asyncCall(callMessage, timeout);
02118     }
02119 
02134     inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
02135     {
02136         if (!invalidationReason().isEmpty()) {
02137             return QDBusPendingReply<uint>(QDBusMessage::createError(
02138                 invalidationReason(),
02139                 invalidationMessage()
02140             ));
02141         }
02142 
02143         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02144                 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
02145         return this->connection().asyncCall(callMessage, timeout);
02146     }
02147 
02173     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
02174     {
02175         if (!invalidationReason().isEmpty()) {
02176             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02177                 invalidationReason(),
02178                 invalidationMessage()
02179             ));
02180         }
02181 
02182         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02183                 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
02184         callMessage << QVariant::fromValue(handles);
02185         return this->connection().asyncCall(callMessage, timeout);
02186     }
02187 
02199     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
02200     {
02201         if (!invalidationReason().isEmpty()) {
02202             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02203                 invalidationReason(),
02204                 invalidationMessage()
02205             ));
02206         }
02207 
02208         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02209                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
02210         return this->connection().asyncCall(callMessage, timeout);
02211     }
02212 
02231     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
02232     {
02233         if (!invalidationReason().isEmpty()) {
02234             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
02235                 invalidationReason(),
02236                 invalidationMessage()
02237             ));
02238         }
02239 
02240         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02241                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
02242         return this->connection().asyncCall(callMessage, timeout);
02243     }
02244 
02255     inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
02256     {
02257         if (!invalidationReason().isEmpty()) {
02258             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02259                 invalidationReason(),
02260                 invalidationMessage()
02261             ));
02262         }
02263 
02264         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02265                 this->staticInterfaceName(), QLatin1String("GetMembers"));
02266         return this->connection().asyncCall(callMessage, timeout);
02267     }
02268 
02280     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
02281     {
02282         if (!invalidationReason().isEmpty()) {
02283             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02284                 invalidationReason(),
02285                 invalidationMessage()
02286             ));
02287         }
02288 
02289         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02290                 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
02291         return this->connection().asyncCall(callMessage, timeout);
02292     }
02293 
02304     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
02305     {
02306         if (!invalidationReason().isEmpty()) {
02307             return QDBusPendingReply<uint>(QDBusMessage::createError(
02308                 invalidationReason(),
02309                 invalidationMessage()
02310             ));
02311         }
02312 
02313         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02314                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
02315         return this->connection().asyncCall(callMessage, timeout);
02316     }
02317 
02371     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02372     {
02373         if (!invalidationReason().isEmpty()) {
02374             return QDBusPendingReply<>(QDBusMessage::createError(
02375                 invalidationReason(),
02376                 invalidationMessage()
02377             ));
02378         }
02379 
02380         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02381                 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
02382         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02383         return this->connection().asyncCall(callMessage, timeout);
02384     }
02385 
02410     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
02411     {
02412         if (!invalidationReason().isEmpty()) {
02413             return QDBusPendingReply<>(QDBusMessage::createError(
02414                 invalidationReason(),
02415                 invalidationMessage()
02416             ));
02417         }
02418 
02419         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02420                 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
02421         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
02422         return this->connection().asyncCall(callMessage, timeout);
02423     }
02424 
02425 Q_SIGNALS:
02444     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
02445 
02455     void SelfHandleChanged(uint selfHandle);
02456 
02471     void GroupFlagsChanged(uint added, uint removed);
02472 
02524     void MembersChanged(const QString& message, const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, uint actor, uint reason);
02525 
02630     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
02631 
02632 protected:
02633     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02634 };
02635 
02643 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
02644 {
02645     Q_OBJECT
02646 
02647 public:
02654     static inline QLatin1String staticInterfaceName()
02655     {
02656         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
02657     }
02658 
02666     ChannelInterfaceHoldInterface(
02667         const QString& busName,
02668         const QString& objectPath,
02669         QObject* parent = 0
02670     );
02671 
02680     ChannelInterfaceHoldInterface(
02681         const QDBusConnection& connection,
02682         const QString& busName,
02683         const QString& objectPath,
02684         QObject* parent = 0
02685     );
02686 
02693     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
02694 
02702     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
02703 
02711     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02712 
02719     Tp::PendingVariantMap *requestAllProperties() const
02720     {
02721         return internalRequestAllProperties();
02722     }
02723 
02724 public Q_SLOTS:
02743     inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
02744     {
02745         if (!invalidationReason().isEmpty()) {
02746             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
02747                 invalidationReason(),
02748                 invalidationMessage()
02749             ));
02750         }
02751 
02752         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02753                 this->staticInterfaceName(), QLatin1String("GetHoldState"));
02754         return this->connection().asyncCall(callMessage, timeout);
02755     }
02756 
02818     inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
02819     {
02820         if (!invalidationReason().isEmpty()) {
02821             return QDBusPendingReply<>(QDBusMessage::createError(
02822                 invalidationReason(),
02823                 invalidationMessage()
02824             ));
02825         }
02826 
02827         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02828                 this->staticInterfaceName(), QLatin1String("RequestHold"));
02829         callMessage << QVariant::fromValue(hold);
02830         return this->connection().asyncCall(callMessage, timeout);
02831     }
02832 
02833 Q_SIGNALS:
02850     void HoldStateChanged(uint holdState, uint reason);
02851 
02852 protected:
02853     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02854 };
02855 
02863 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
02864 {
02865     Q_OBJECT
02866 
02867 public:
02874     static inline QLatin1String staticInterfaceName()
02875     {
02876         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
02877     }
02878 
02886     ChannelInterfaceMediaSignallingInterface(
02887         const QString& busName,
02888         const QString& objectPath,
02889         QObject* parent = 0
02890     );
02891 
02900     ChannelInterfaceMediaSignallingInterface(
02901         const QDBusConnection& connection,
02902         const QString& busName,
02903         const QString& objectPath,
02904         QObject* parent = 0
02905     );
02906 
02913     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
02914 
02922     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
02923 
02931     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02932 
02939     Tp::PendingVariantMap *requestAllProperties() const
02940     {
02941         return internalRequestAllProperties();
02942     }
02943 
02944 public Q_SLOTS:
02956     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
02957     {
02958         if (!invalidationReason().isEmpty()) {
02959             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02960                 invalidationReason(),
02961                 invalidationMessage()
02962             ));
02963         }
02964 
02965         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02966                 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
02967         return this->connection().asyncCall(callMessage, timeout);
02968     }
02969 
02970 Q_SIGNALS:
02986     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02987 
02988 protected:
02989     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02990 };
02991 
02999 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
03000 {
03001     Q_OBJECT
03002 
03003 public:
03010     static inline QLatin1String staticInterfaceName()
03011     {
03012         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
03013     }
03014 
03022     ChannelInterfaceMessagesInterface(
03023         const QString& busName,
03024         const QString& objectPath,
03025         QObject* parent = 0
03026     );
03027 
03036     ChannelInterfaceMessagesInterface(
03037         const QDBusConnection& connection,
03038         const QString& busName,
03039         const QString& objectPath,
03040         QObject* parent = 0
03041     );
03042 
03049     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
03050 
03058     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
03059 
03067     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03068 
03120     inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
03121     {
03122         return internalRequestProperty(QLatin1String("SupportedContentTypes"));
03123     }
03124 
03134     inline Tp::PendingVariant *requestPropertyMessageTypes() const
03135     {
03136         return internalRequestProperty(QLatin1String("MessageTypes"));
03137     }
03138 
03148     inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
03149     {
03150         return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
03151     }
03152 
03171     inline Tp::PendingVariant *requestPropertyPendingMessages() const
03172     {
03173         return internalRequestProperty(QLatin1String("PendingMessages"));
03174     }
03175 
03185     inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
03186     {
03187         return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
03188     }
03189 
03196     Tp::PendingVariantMap *requestAllProperties() const
03197     {
03198         return internalRequestAllProperties();
03199     }
03200 
03201 public Q_SLOTS:
03262     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
03263     {
03264         if (!invalidationReason().isEmpty()) {
03265             return QDBusPendingReply<QString>(QDBusMessage::createError(
03266                 invalidationReason(),
03267                 invalidationMessage()
03268             ));
03269         }
03270 
03271         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03272                 this->staticInterfaceName(), QLatin1String("SendMessage"));
03273         callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
03274         return this->connection().asyncCall(callMessage, timeout);
03275     }
03276 
03315     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
03316     {
03317         if (!invalidationReason().isEmpty()) {
03318             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
03319                 invalidationReason(),
03320                 invalidationMessage()
03321             ));
03322         }
03323 
03324         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03325                 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
03326         callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
03327         return this->connection().asyncCall(callMessage, timeout);
03328     }
03329 
03330 Q_SIGNALS:
03386     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
03387 
03401     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
03402 
03421     void MessageReceived(const Tp::MessagePartList& message);
03422 
03423 protected:
03424     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03425 };
03426 
03434 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
03435 {
03436     Q_OBJECT
03437 
03438 public:
03445     static inline QLatin1String staticInterfaceName()
03446     {
03447         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
03448     }
03449 
03457     ChannelInterfacePasswordInterface(
03458         const QString& busName,
03459         const QString& objectPath,
03460         QObject* parent = 0
03461     );
03462 
03471     ChannelInterfacePasswordInterface(
03472         const QDBusConnection& connection,
03473         const QString& busName,
03474         const QString& objectPath,
03475         QObject* parent = 0
03476     );
03477 
03484     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
03485 
03493     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
03494 
03502     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03503 
03510     Tp::PendingVariantMap *requestAllProperties() const
03511     {
03512         return internalRequestAllProperties();
03513     }
03514 
03515 public Q_SLOTS:
03533     inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
03534     {
03535         if (!invalidationReason().isEmpty()) {
03536             return QDBusPendingReply<uint>(QDBusMessage::createError(
03537                 invalidationReason(),
03538                 invalidationMessage()
03539             ));
03540         }
03541 
03542         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03543                 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
03544         return this->connection().asyncCall(callMessage, timeout);
03545     }
03546 
03567     inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
03568     {
03569         if (!invalidationReason().isEmpty()) {
03570             return QDBusPendingReply<bool>(QDBusMessage::createError(
03571                 invalidationReason(),
03572                 invalidationMessage()
03573             ));
03574         }
03575 
03576         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03577                 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
03578         callMessage << QVariant::fromValue(password);
03579         return this->connection().asyncCall(callMessage, timeout);
03580     }
03581 
03582 Q_SIGNALS:
03597     void PasswordFlagsChanged(uint added, uint removed);
03598 
03599 protected:
03600     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03601 };
03602 
03610 class TELEPATHY_QT4_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
03611 {
03612     Q_OBJECT
03613 
03614 public:
03621     static inline QLatin1String staticInterfaceName()
03622     {
03623         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
03624     }
03625 
03633     ChannelInterfaceSASLAuthenticationInterface(
03634         const QString& busName,
03635         const QString& objectPath,
03636         QObject* parent = 0
03637     );
03638 
03647     ChannelInterfaceSASLAuthenticationInterface(
03648         const QDBusConnection& connection,
03649         const QString& busName,
03650         const QString& objectPath,
03651         QObject* parent = 0
03652     );
03653 
03660     ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
03661 
03669     explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
03670 
03678     ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03679 
03700     inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
03701     {
03702         return internalRequestProperty(QLatin1String("AvailableMechanisms"));
03703     }
03704 
03724     inline Tp::PendingVariant *requestPropertyHasInitialData() const
03725     {
03726         return internalRequestProperty(QLatin1String("HasInitialData"));
03727     }
03728 
03747     inline Tp::PendingVariant *requestPropertyCanTryAgain() const
03748     {
03749         return internalRequestProperty(QLatin1String("CanTryAgain"));
03750     }
03751 
03763     inline Tp::PendingVariant *requestPropertySASLStatus() const
03764     {
03765         return internalRequestProperty(QLatin1String("SASLStatus"));
03766     }
03767 
03794     inline Tp::PendingVariant *requestPropertySASLError() const
03795     {
03796         return internalRequestProperty(QLatin1String("SASLError"));
03797     }
03798 
03818     inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
03819     {
03820         return internalRequestProperty(QLatin1String("SASLErrorDetails"));
03821     }
03822 
03885     inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
03886     {
03887         return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
03888     }
03889 
03949     inline Tp::PendingVariant *requestPropertyDefaultUsername() const
03950     {
03951         return internalRequestProperty(QLatin1String("DefaultUsername"));
03952     }
03953 
03979     inline Tp::PendingVariant *requestPropertyDefaultRealm() const
03980     {
03981         return internalRequestProperty(QLatin1String("DefaultRealm"));
03982     }
03983 
03990     Tp::PendingVariantMap *requestAllProperties() const
03991     {
03992         return internalRequestAllProperties();
03993     }
03994 
03995 public Q_SLOTS:
04020     inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
04021     {
04022         if (!invalidationReason().isEmpty()) {
04023             return QDBusPendingReply<>(QDBusMessage::createError(
04024                 invalidationReason(),
04025                 invalidationMessage()
04026             ));
04027         }
04028 
04029         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04030                 this->staticInterfaceName(), QLatin1String("StartMechanism"));
04031         callMessage << QVariant::fromValue(mechanism);
04032         return this->connection().asyncCall(callMessage, timeout);
04033     }
04034 
04087     inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
04088     {
04089         if (!invalidationReason().isEmpty()) {
04090             return QDBusPendingReply<>(QDBusMessage::createError(
04091                 invalidationReason(),
04092                 invalidationMessage()
04093             ));
04094         }
04095 
04096         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04097                 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
04098         callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
04099         return this->connection().asyncCall(callMessage, timeout);
04100     }
04101 
04117     inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
04118     {
04119         if (!invalidationReason().isEmpty()) {
04120             return QDBusPendingReply<>(QDBusMessage::createError(
04121                 invalidationReason(),
04122                 invalidationMessage()
04123             ));
04124         }
04125 
04126         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04127                 this->staticInterfaceName(), QLatin1String("Respond"));
04128         callMessage << QVariant::fromValue(responseData);
04129         return this->connection().asyncCall(callMessage, timeout);
04130     }
04131 
04158     inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
04159     {
04160         if (!invalidationReason().isEmpty()) {
04161             return QDBusPendingReply<>(QDBusMessage::createError(
04162                 invalidationReason(),
04163                 invalidationMessage()
04164             ));
04165         }
04166 
04167         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04168                 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
04169         return this->connection().asyncCall(callMessage, timeout);
04170     }
04171 
04198     inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
04199     {
04200         if (!invalidationReason().isEmpty()) {
04201             return QDBusPendingReply<>(QDBusMessage::createError(
04202                 invalidationReason(),
04203                 invalidationMessage()
04204             ));
04205         }
04206 
04207         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04208                 this->staticInterfaceName(), QLatin1String("AbortSASL"));
04209         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
04210         return this->connection().asyncCall(callMessage, timeout);
04211     }
04212 
04213 Q_SIGNALS:
04231     void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
04232 
04250     void NewChallenge(const QByteArray& challengeData);
04251 
04252 protected:
04253     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04254 };
04255 
04263 class TELEPATHY_QT4_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
04264 {
04265     Q_OBJECT
04266 
04267 public:
04274     static inline QLatin1String staticInterfaceName()
04275     {
04276         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
04277     }
04278 
04286     ChannelInterfaceSecurableInterface(
04287         const QString& busName,
04288         const QString& objectPath,
04289         QObject* parent = 0
04290     );
04291 
04300     ChannelInterfaceSecurableInterface(
04301         const QDBusConnection& connection,
04302         const QString& busName,
04303         const QString& objectPath,
04304         QObject* parent = 0
04305     );
04306 
04313     ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
04314 
04322     explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
04323 
04331     ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04332 
04352     inline Tp::PendingVariant *requestPropertyEncrypted() const
04353     {
04354         return internalRequestProperty(QLatin1String("Encrypted"));
04355     }
04356 
04371     inline Tp::PendingVariant *requestPropertyVerified() const
04372     {
04373         return internalRequestProperty(QLatin1String("Verified"));
04374     }
04375 
04382     Tp::PendingVariantMap *requestAllProperties() const
04383     {
04384         return internalRequestAllProperties();
04385     }
04386 
04387 protected:
04388     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04389 };
04390 
04398 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
04399 {
04400     Q_OBJECT
04401 
04402 public:
04409     static inline QLatin1String staticInterfaceName()
04410     {
04411         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
04412     }
04413 
04421     ChannelInterfaceServicePointInterface(
04422         const QString& busName,
04423         const QString& objectPath,
04424         QObject* parent = 0
04425     );
04426 
04435     ChannelInterfaceServicePointInterface(
04436         const QDBusConnection& connection,
04437         const QString& busName,
04438         const QString& objectPath,
04439         QObject* parent = 0
04440     );
04441 
04448     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
04449 
04457     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
04458 
04466     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04467 
04485     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
04486     {
04487         return internalRequestProperty(QLatin1String("InitialServicePoint"));
04488     }
04489 
04502     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
04503     {
04504         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
04505     }
04506 
04513     Tp::PendingVariantMap *requestAllProperties() const
04514     {
04515         return internalRequestAllProperties();
04516     }
04517 
04518 Q_SIGNALS:
04535     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
04536 
04537 protected:
04538     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04539 };
04540 
04548 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
04549 {
04550     Q_OBJECT
04551 
04552 public:
04559     static inline QLatin1String staticInterfaceName()
04560     {
04561         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
04562     }
04563 
04571     ChannelInterfaceTubeInterface(
04572         const QString& busName,
04573         const QString& objectPath,
04574         QObject* parent = 0
04575     );
04576 
04585     ChannelInterfaceTubeInterface(
04586         const QDBusConnection& connection,
04587         const QString& busName,
04588         const QString& objectPath,
04589         QObject* parent = 0
04590     );
04591 
04598     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
04599 
04607     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
04608 
04616     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04617 
04661     inline Tp::PendingVariant *requestPropertyParameters() const
04662     {
04663         return internalRequestProperty(QLatin1String("Parameters"));
04664     }
04665 
04679     inline Tp::PendingVariant *requestPropertyState() const
04680     {
04681         return internalRequestProperty(QLatin1String("State"));
04682     }
04683 
04690     Tp::PendingVariantMap *requestAllProperties() const
04691     {
04692         return internalRequestAllProperties();
04693     }
04694 
04695 Q_SIGNALS:
04706     void TubeChannelStateChanged(uint state);
04707 
04708 protected:
04709     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04710 };
04711 
04719 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
04720 {
04721     Q_OBJECT
04722 
04723 public:
04730     static inline QLatin1String staticInterfaceName()
04731     {
04732         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
04733     }
04734 
04742     ChannelTypeContactListInterface(
04743         const QString& busName,
04744         const QString& objectPath,
04745         QObject* parent = 0
04746     );
04747 
04756     ChannelTypeContactListInterface(
04757         const QDBusConnection& connection,
04758         const QString& busName,
04759         const QString& objectPath,
04760         QObject* parent = 0
04761     );
04762 
04769     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
04770 
04778     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
04779 
04787     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04788 
04795     Tp::PendingVariantMap *requestAllProperties() const
04796     {
04797         return internalRequestAllProperties();
04798     }
04799 
04800 protected:
04801     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04802 };
04803 
04811 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
04812 {
04813     Q_OBJECT
04814 
04815 public:
04822     static inline QLatin1String staticInterfaceName()
04823     {
04824         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
04825     }
04826 
04834     ChannelTypeContactSearchInterface(
04835         const QString& busName,
04836         const QString& objectPath,
04837         QObject* parent = 0
04838     );
04839 
04848     ChannelTypeContactSearchInterface(
04849         const QDBusConnection& connection,
04850         const QString& busName,
04851         const QString& objectPath,
04852         QObject* parent = 0
04853     );
04854 
04861     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
04862 
04870     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
04871 
04879     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04880 
04891     inline Tp::PendingVariant *requestPropertySearchState() const
04892     {
04893         return internalRequestProperty(QLatin1String("SearchState"));
04894     }
04895 
04919     inline Tp::PendingVariant *requestPropertyLimit() const
04920     {
04921         return internalRequestProperty(QLatin1String("Limit"));
04922     }
04923 
04938     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
04939     {
04940         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
04941     }
04942 
04963     inline Tp::PendingVariant *requestPropertyServer() const
04964     {
04965         return internalRequestProperty(QLatin1String("Server"));
04966     }
04967 
04974     Tp::PendingVariantMap *requestAllProperties() const
04975     {
04976         return internalRequestAllProperties();
04977     }
04978 
04979 public Q_SLOTS:
04997     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
04998     {
04999         if (!invalidationReason().isEmpty()) {
05000             return QDBusPendingReply<>(QDBusMessage::createError(
05001                 invalidationReason(),
05002                 invalidationMessage()
05003             ));
05004         }
05005 
05006         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05007                 this->staticInterfaceName(), QLatin1String("Search"));
05008         callMessage << QVariant::fromValue(terms);
05009         return this->connection().asyncCall(callMessage, timeout);
05010     }
05011 
05024     inline QDBusPendingReply<> More(int timeout = -1)
05025     {
05026         if (!invalidationReason().isEmpty()) {
05027             return QDBusPendingReply<>(QDBusMessage::createError(
05028                 invalidationReason(),
05029                 invalidationMessage()
05030             ));
05031         }
05032 
05033         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05034                 this->staticInterfaceName(), QLatin1String("More"));
05035         return this->connection().asyncCall(callMessage, timeout);
05036     }
05037 
05068     inline QDBusPendingReply<> Stop(int timeout = -1)
05069     {
05070         if (!invalidationReason().isEmpty()) {
05071             return QDBusPendingReply<>(QDBusMessage::createError(
05072                 invalidationReason(),
05073                 invalidationMessage()
05074             ));
05075         }
05076 
05077         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05078                 this->staticInterfaceName(), QLatin1String("Stop"));
05079         return this->connection().asyncCall(callMessage, timeout);
05080     }
05081 
05082 Q_SIGNALS:
05126     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
05127 
05140     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
05141 
05142 protected:
05143     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05144 };
05145 
05153 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
05154 {
05155     Q_OBJECT
05156 
05157 public:
05164     static inline QLatin1String staticInterfaceName()
05165     {
05166         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
05167     }
05168 
05176     ChannelTypeFileTransferInterface(
05177         const QString& busName,
05178         const QString& objectPath,
05179         QObject* parent = 0
05180     );
05181 
05190     ChannelTypeFileTransferInterface(
05191         const QDBusConnection& connection,
05192         const QString& busName,
05193         const QString& objectPath,
05194         QObject* parent = 0
05195     );
05196 
05203     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
05204 
05212     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
05213 
05221     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05222 
05233     inline Tp::PendingVariant *requestPropertyState() const
05234     {
05235         return internalRequestProperty(QLatin1String("State"));
05236     }
05237 
05253     inline Tp::PendingVariant *requestPropertyContentType() const
05254     {
05255         return internalRequestProperty(QLatin1String("ContentType"));
05256     }
05257 
05277     inline Tp::PendingVariant *requestPropertyFilename() const
05278     {
05279         return internalRequestProperty(QLatin1String("Filename"));
05280     }
05281 
05303     inline Tp::PendingVariant *requestPropertySize() const
05304     {
05305         return internalRequestProperty(QLatin1String("Size"));
05306     }
05307 
05332     inline Tp::PendingVariant *requestPropertyContentHashType() const
05333     {
05334         return internalRequestProperty(QLatin1String("ContentHashType"));
05335     }
05336 
05355     inline Tp::PendingVariant *requestPropertyContentHash() const
05356     {
05357         return internalRequestProperty(QLatin1String("ContentHash"));
05358     }
05359 
05375     inline Tp::PendingVariant *requestPropertyDescription() const
05376     {
05377         return internalRequestProperty(QLatin1String("Description"));
05378     }
05379 
05394     inline Tp::PendingVariant *requestPropertyDate() const
05395     {
05396         return internalRequestProperty(QLatin1String("Date"));
05397     }
05398 
05425     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
05426     {
05427         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
05428     }
05429 
05441     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
05442     {
05443         return internalRequestProperty(QLatin1String("TransferredBytes"));
05444     }
05445 
05466     inline Tp::PendingVariant *requestPropertyInitialOffset() const
05467     {
05468         return internalRequestProperty(QLatin1String("InitialOffset"));
05469     }
05470 
05477     Tp::PendingVariantMap *requestAllProperties() const
05478     {
05479         return internalRequestAllProperties();
05480     }
05481 
05482 public Q_SLOTS:
05527     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
05528     {
05529         if (!invalidationReason().isEmpty()) {
05530             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05531                 invalidationReason(),
05532                 invalidationMessage()
05533             ));
05534         }
05535 
05536         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05537                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
05538         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
05539         return this->connection().asyncCall(callMessage, timeout);
05540     }
05541 
05575     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
05576     {
05577         if (!invalidationReason().isEmpty()) {
05578             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05579                 invalidationReason(),
05580                 invalidationMessage()
05581             ));
05582         }
05583 
05584         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05585                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
05586         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05587         return this->connection().asyncCall(callMessage, timeout);
05588     }
05589 
05590 Q_SIGNALS:
05608     void FileTransferStateChanged(uint state, uint reason);
05609 
05622     void TransferredBytesChanged(qulonglong count);
05623 
05635     void InitialOffsetDefined(qulonglong initialOffset);
05636 
05637 protected:
05638     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05639 };
05640 
05648 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
05649 {
05650     Q_OBJECT
05651 
05652 public:
05659     static inline QLatin1String staticInterfaceName()
05660     {
05661         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
05662     }
05663 
05671     ChannelTypeRoomListInterface(
05672         const QString& busName,
05673         const QString& objectPath,
05674         QObject* parent = 0
05675     );
05676 
05685     ChannelTypeRoomListInterface(
05686         const QDBusConnection& connection,
05687         const QString& busName,
05688         const QString& objectPath,
05689         QObject* parent = 0
05690     );
05691 
05698     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
05699 
05707     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
05708 
05716     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05717 
05731     inline Tp::PendingVariant *requestPropertyServer() const
05732     {
05733         return internalRequestProperty(QLatin1String("Server"));
05734     }
05735 
05742     Tp::PendingVariantMap *requestAllProperties() const
05743     {
05744         return internalRequestAllProperties();
05745     }
05746 
05747 public Q_SLOTS:
05763     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
05764     {
05765         if (!invalidationReason().isEmpty()) {
05766             return QDBusPendingReply<bool>(QDBusMessage::createError(
05767                 invalidationReason(),
05768                 invalidationMessage()
05769             ));
05770         }
05771 
05772         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05773                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
05774         return this->connection().asyncCall(callMessage, timeout);
05775     }
05776 
05790     inline QDBusPendingReply<> ListRooms(int timeout = -1)
05791     {
05792         if (!invalidationReason().isEmpty()) {
05793             return QDBusPendingReply<>(QDBusMessage::createError(
05794                 invalidationReason(),
05795                 invalidationMessage()
05796             ));
05797         }
05798 
05799         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05800                 this->staticInterfaceName(), QLatin1String("ListRooms"));
05801         return this->connection().asyncCall(callMessage, timeout);
05802     }
05803 
05816     inline QDBusPendingReply<> StopListing(int timeout = -1)
05817     {
05818         if (!invalidationReason().isEmpty()) {
05819             return QDBusPendingReply<>(QDBusMessage::createError(
05820                 invalidationReason(),
05821                 invalidationMessage()
05822             ));
05823         }
05824 
05825         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05826                 this->staticInterfaceName(), QLatin1String("StopListing"));
05827         return this->connection().asyncCall(callMessage, timeout);
05828     }
05829 
05830 Q_SIGNALS:
05884     void GotRooms(const Tp::RoomInfoList& rooms);
05885 
05896     void ListingRooms(bool listing);
05897 
05898 protected:
05899     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05900 };
05901 
05909 class TELEPATHY_QT4_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
05910 {
05911     Q_OBJECT
05912 
05913 public:
05920     static inline QLatin1String staticInterfaceName()
05921     {
05922         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
05923     }
05924 
05932     ChannelTypeServerAuthenticationInterface(
05933         const QString& busName,
05934         const QString& objectPath,
05935         QObject* parent = 0
05936     );
05937 
05946     ChannelTypeServerAuthenticationInterface(
05947         const QDBusConnection& connection,
05948         const QString& busName,
05949         const QString& objectPath,
05950         QObject* parent = 0
05951     );
05952 
05959     ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
05960 
05968     explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
05969 
05977     ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05978 
05993     inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
05994     {
05995         return internalRequestProperty(QLatin1String("AuthenticationMethod"));
05996     }
05997 
06004     Tp::PendingVariantMap *requestAllProperties() const
06005     {
06006         return internalRequestAllProperties();
06007     }
06008 
06009 protected:
06010     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06011 };
06012 
06020 class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
06021 {
06022     Q_OBJECT
06023 
06024 public:
06031     static inline QLatin1String staticInterfaceName()
06032     {
06033         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
06034     }
06035 
06043     ChannelTypeServerTLSConnectionInterface(
06044         const QString& busName,
06045         const QString& objectPath,
06046         QObject* parent = 0
06047     );
06048 
06057     ChannelTypeServerTLSConnectionInterface(
06058         const QDBusConnection& connection,
06059         const QString& busName,
06060         const QString& objectPath,
06061         QObject* parent = 0
06062     );
06063 
06070     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
06071 
06079     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
06080 
06088     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06089 
06100     inline Tp::PendingVariant *requestPropertyServerCertificate() const
06101     {
06102         return internalRequestProperty(QLatin1String("ServerCertificate"));
06103     }
06104 
06116     inline Tp::PendingVariant *requestPropertyHostname() const
06117     {
06118         return internalRequestProperty(QLatin1String("Hostname"));
06119     }
06120 
06127     Tp::PendingVariantMap *requestAllProperties() const
06128     {
06129         return internalRequestAllProperties();
06130     }
06131 
06132 protected:
06133     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06134 };
06135 
06143 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
06144 {
06145     Q_OBJECT
06146 
06147 public:
06154     static inline QLatin1String staticInterfaceName()
06155     {
06156         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
06157     }
06158 
06166     ChannelTypeStreamTubeInterface(
06167         const QString& busName,
06168         const QString& objectPath,
06169         QObject* parent = 0
06170     );
06171 
06180     ChannelTypeStreamTubeInterface(
06181         const QDBusConnection& connection,
06182         const QString& busName,
06183         const QString& objectPath,
06184         QObject* parent = 0
06185     );
06186 
06193     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
06194 
06202     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
06203 
06211     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06212 
06233     inline Tp::PendingVariant *requestPropertyService() const
06234     {
06235         return internalRequestProperty(QLatin1String("Service"));
06236     }
06237 
06270     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
06271     {
06272         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
06273     }
06274 
06281     Tp::PendingVariantMap *requestAllProperties() const
06282     {
06283         return internalRequestAllProperties();
06284     }
06285 
06286 public Q_SLOTS:
06317     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
06318     {
06319         if (!invalidationReason().isEmpty()) {
06320             return QDBusPendingReply<>(QDBusMessage::createError(
06321                 invalidationReason(),
06322                 invalidationMessage()
06323             ));
06324         }
06325 
06326         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06327                 this->staticInterfaceName(), QLatin1String("Offer"));
06328         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
06329         return this->connection().asyncCall(callMessage, timeout);
06330     }
06331 
06370     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
06371     {
06372         if (!invalidationReason().isEmpty()) {
06373             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06374                 invalidationReason(),
06375                 invalidationMessage()
06376             ));
06377         }
06378 
06379         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06380                 this->staticInterfaceName(), QLatin1String("Accept"));
06381         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
06382         return this->connection().asyncCall(callMessage, timeout);
06383     }
06384 
06385 Q_SIGNALS:
06422     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
06423 
06437     void NewLocalConnection(uint connectionID);
06438 
06466     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
06467 
06468 protected:
06469     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06470 };
06471 
06479 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
06480 {
06481     Q_OBJECT
06482 
06483 public:
06490     static inline QLatin1String staticInterfaceName()
06491     {
06492         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
06493     }
06494 
06502     ChannelTypeStreamedMediaInterface(
06503         const QString& busName,
06504         const QString& objectPath,
06505         QObject* parent = 0
06506     );
06507 
06516     ChannelTypeStreamedMediaInterface(
06517         const QDBusConnection& connection,
06518         const QString& busName,
06519         const QString& objectPath,
06520         QObject* parent = 0
06521     );
06522 
06529     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
06530 
06538     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
06539 
06547     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06548 
06635     inline Tp::PendingVariant *requestPropertyInitialAudio() const
06636     {
06637         return internalRequestProperty(QLatin1String("InitialAudio"));
06638     }
06639 
06658     inline Tp::PendingVariant *requestPropertyInitialVideo() const
06659     {
06660         return internalRequestProperty(QLatin1String("InitialVideo"));
06661     }
06662 
06703     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
06704     {
06705         return internalRequestProperty(QLatin1String("ImmutableStreams"));
06706     }
06707 
06714     Tp::PendingVariantMap *requestAllProperties() const
06715     {
06716         return internalRequestAllProperties();
06717     }
06718 
06719 public Q_SLOTS:
06745     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
06746     {
06747         if (!invalidationReason().isEmpty()) {
06748             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
06749                 invalidationReason(),
06750                 invalidationMessage()
06751             ));
06752         }
06753 
06754         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06755                 this->staticInterfaceName(), QLatin1String("ListStreams"));
06756         return this->connection().asyncCall(callMessage, timeout);
06757     }
06758 
06783     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
06784     {
06785         if (!invalidationReason().isEmpty()) {
06786             return QDBusPendingReply<>(QDBusMessage::createError(
06787                 invalidationReason(),
06788                 invalidationMessage()
06789             ));
06790         }
06791 
06792         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06793                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
06794         callMessage << QVariant::fromValue(streams);
06795         return this->connection().asyncCall(callMessage, timeout);
06796     }
06797 
06832     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
06833     {
06834         if (!invalidationReason().isEmpty()) {
06835             return QDBusPendingReply<>(QDBusMessage::createError(
06836                 invalidationReason(),
06837                 invalidationMessage()
06838             ));
06839         }
06840 
06841         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06842                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
06843         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
06844         return this->connection().asyncCall(callMessage, timeout);
06845     }
06846 
06895     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
06896     {
06897         if (!invalidationReason().isEmpty()) {
06898             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
06899                 invalidationReason(),
06900                 invalidationMessage()
06901             ));
06902         }
06903 
06904         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06905                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
06906         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
06907         return this->connection().asyncCall(callMessage, timeout);
06908     }
06909 
06910 Q_SIGNALS:
06975     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
06976 
07006     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
07007 
07025     void StreamError(uint streamID, uint errorCode, const QString& message);
07026 
07036     void StreamRemoved(uint streamID);
07037 
07051     void StreamStateChanged(uint streamID, uint streamState);
07052 
07053 protected:
07054     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07055 };
07056 
07064 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
07065 {
07066     Q_OBJECT
07067 
07068 public:
07075     static inline QLatin1String staticInterfaceName()
07076     {
07077         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
07078     }
07079 
07087     ChannelTypeTextInterface(
07088         const QString& busName,
07089         const QString& objectPath,
07090         QObject* parent = 0
07091     );
07092 
07101     ChannelTypeTextInterface(
07102         const QDBusConnection& connection,
07103         const QString& busName,
07104         const QString& objectPath,
07105         QObject* parent = 0
07106     );
07107 
07114     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
07115 
07123     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
07124 
07132     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07133 
07140     Tp::PendingVariantMap *requestAllProperties() const
07141     {
07142         return internalRequestAllProperties();
07143     }
07144 
07145 public Q_SLOTS:
07161     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
07162     {
07163         if (!invalidationReason().isEmpty()) {
07164             return QDBusPendingReply<>(QDBusMessage::createError(
07165                 invalidationReason(),
07166                 invalidationMessage()
07167             ));
07168         }
07169 
07170         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07171                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
07172         callMessage << QVariant::fromValue(IDs);
07173         return this->connection().asyncCall(callMessage, timeout);
07174     }
07175 
07191     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
07192     {
07193         if (!invalidationReason().isEmpty()) {
07194             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
07195                 invalidationReason(),
07196                 invalidationMessage()
07197             ));
07198         }
07199 
07200         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07201                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
07202         return this->connection().asyncCall(callMessage, timeout);
07203     }
07204 
07233     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
07234     {
07235         if (!invalidationReason().isEmpty()) {
07236             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
07237                 invalidationReason(),
07238                 invalidationMessage()
07239             ));
07240         }
07241 
07242         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07243                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
07244         callMessage << QVariant::fromValue(clear);
07245         return this->connection().asyncCall(callMessage, timeout);
07246     }
07247 
07278     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
07279     {
07280         if (!invalidationReason().isEmpty()) {
07281             return QDBusPendingReply<>(QDBusMessage::createError(
07282                 invalidationReason(),
07283                 invalidationMessage()
07284             ));
07285         }
07286 
07287         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07288                 this->staticInterfaceName(), QLatin1String("Send"));
07289         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
07290         return this->connection().asyncCall(callMessage, timeout);
07291     }
07292 
07293 Q_SIGNALS:
07301     void LostMessage();
07302 
07336     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
07337 
07364     void SendError(uint error, uint timestamp, uint type, const QString& text);
07365 
07387     void Sent(uint timestamp, uint type, const QString& text);
07388 
07389 protected:
07390     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07391 };
07392 
07400 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
07401 {
07402     Q_OBJECT
07403 
07404 public:
07411     static inline QLatin1String staticInterfaceName()
07412     {
07413         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
07414     }
07415 
07423     ChannelTypeTubesInterface(
07424         const QString& busName,
07425         const QString& objectPath,
07426         QObject* parent = 0
07427     );
07428 
07437     ChannelTypeTubesInterface(
07438         const QDBusConnection& connection,
07439         const QString& busName,
07440         const QString& objectPath,
07441         QObject* parent = 0
07442     );
07443 
07450     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
07451 
07459     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
07460 
07468     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07469 
07476     Tp::PendingVariantMap *requestAllProperties() const
07477     {
07478         return internalRequestAllProperties();
07479     }
07480 
07481 public Q_SLOTS:
07516     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
07517     {
07518         if (!invalidationReason().isEmpty()) {
07519             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
07520                 invalidationReason(),
07521                 invalidationMessage()
07522             ));
07523         }
07524 
07525         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07526                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
07527         return this->connection().asyncCall(callMessage, timeout);
07528     }
07529 
07543     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
07544     {
07545         if (!invalidationReason().isEmpty()) {
07546             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
07547                 invalidationReason(),
07548                 invalidationMessage()
07549             ));
07550         }
07551 
07552         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07553                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
07554         return this->connection().asyncCall(callMessage, timeout);
07555     }
07556 
07572     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
07573     {
07574         if (!invalidationReason().isEmpty()) {
07575             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
07576                 invalidationReason(),
07577                 invalidationMessage()
07578             ));
07579         }
07580 
07581         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07582                 this->staticInterfaceName(), QLatin1String("ListTubes"));
07583         return this->connection().asyncCall(callMessage, timeout);
07584     }
07585 
07613     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
07614     {
07615         if (!invalidationReason().isEmpty()) {
07616             return QDBusPendingReply<uint>(QDBusMessage::createError(
07617                 invalidationReason(),
07618                 invalidationMessage()
07619             ));
07620         }
07621 
07622         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07623                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
07624         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
07625         return this->connection().asyncCall(callMessage, timeout);
07626     }
07627 
07683     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
07684     {
07685         if (!invalidationReason().isEmpty()) {
07686             return QDBusPendingReply<uint>(QDBusMessage::createError(
07687                 invalidationReason(),
07688                 invalidationMessage()
07689             ));
07690         }
07691 
07692         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07693                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
07694         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
07695         return this->connection().asyncCall(callMessage, timeout);
07696     }
07697 
07720     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
07721     {
07722         if (!invalidationReason().isEmpty()) {
07723             return QDBusPendingReply<QString>(QDBusMessage::createError(
07724                 invalidationReason(),
07725                 invalidationMessage()
07726             ));
07727         }
07728 
07729         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07730                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
07731         callMessage << QVariant::fromValue(ID);
07732         return this->connection().asyncCall(callMessage, timeout);
07733     }
07734 
07772     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
07773     {
07774         if (!invalidationReason().isEmpty()) {
07775             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
07776                 invalidationReason(),
07777                 invalidationMessage()
07778             ));
07779         }
07780 
07781         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07782                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
07783         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
07784         return this->connection().asyncCall(callMessage, timeout);
07785     }
07786 
07801     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
07802     {
07803         if (!invalidationReason().isEmpty()) {
07804             return QDBusPendingReply<>(QDBusMessage::createError(
07805                 invalidationReason(),
07806                 invalidationMessage()
07807             ));
07808         }
07809 
07810         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07811                 this->staticInterfaceName(), QLatin1String("CloseTube"));
07812         callMessage << QVariant::fromValue(ID);
07813         return this->connection().asyncCall(callMessage, timeout);
07814     }
07815 
07835     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
07836     {
07837         if (!invalidationReason().isEmpty()) {
07838             return QDBusPendingReply<QString>(QDBusMessage::createError(
07839                 invalidationReason(),
07840                 invalidationMessage()
07841             ));
07842         }
07843 
07844         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07845                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
07846         callMessage << QVariant::fromValue(ID);
07847         return this->connection().asyncCall(callMessage, timeout);
07848     }
07849 
07870     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
07871     {
07872         if (!invalidationReason().isEmpty()) {
07873             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
07874                 invalidationReason(),
07875                 invalidationMessage()
07876             ));
07877         }
07878 
07879         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07880                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
07881         callMessage << QVariant::fromValue(ID);
07882         return this->connection().asyncCall(callMessage, timeout);
07883     }
07884 
07910     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
07911     {
07912         if (!invalidationReason().isEmpty()) {
07913             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
07914                 invalidationReason(),
07915                 invalidationMessage()
07916             ));
07917         }
07918 
07919         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07920                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
07921         callMessage << QVariant::fromValue(ID);
07922         return this->connection().asyncCall(callMessage, timeout);
07923     }
07924 
07925 Q_SIGNALS:
07955     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
07956 
07970     void TubeStateChanged(uint ID, uint state);
07971 
07982     void TubeClosed(uint ID);
07983 
08002     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
08003 
08018     void StreamTubeNewConnection(uint ID, uint handle);
08019 
08020 protected:
08021     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08022 };
08023 }
08024 }
08025 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
08026 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
08027 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
08028 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
08029 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
08030 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
08031 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
08032 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
08033 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
08034 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
08035 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
08036 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
08037 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
08038 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
08039 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
08040 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
08041 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
08042 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
08043 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
08044 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
08045 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
08046 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
08047 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
08048 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
08049 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


Copyright © 2008-2010 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.5.8