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 
04003     inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
04004     {
04005         return internalRequestProperty(QLatin1String("MaySaveResponse"));
04006     }
04007 
04014     Tp::PendingVariantMap *requestAllProperties() const
04015     {
04016         return internalRequestAllProperties();
04017     }
04018 
04019 public Q_SLOTS:
04044     inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
04045     {
04046         if (!invalidationReason().isEmpty()) {
04047             return QDBusPendingReply<>(QDBusMessage::createError(
04048                 invalidationReason(),
04049                 invalidationMessage()
04050             ));
04051         }
04052 
04053         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04054                 this->staticInterfaceName(), QLatin1String("StartMechanism"));
04055         callMessage << QVariant::fromValue(mechanism);
04056         return this->connection().asyncCall(callMessage, timeout);
04057     }
04058 
04111     inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
04112     {
04113         if (!invalidationReason().isEmpty()) {
04114             return QDBusPendingReply<>(QDBusMessage::createError(
04115                 invalidationReason(),
04116                 invalidationMessage()
04117             ));
04118         }
04119 
04120         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04121                 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
04122         callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
04123         return this->connection().asyncCall(callMessage, timeout);
04124     }
04125 
04141     inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
04142     {
04143         if (!invalidationReason().isEmpty()) {
04144             return QDBusPendingReply<>(QDBusMessage::createError(
04145                 invalidationReason(),
04146                 invalidationMessage()
04147             ));
04148         }
04149 
04150         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04151                 this->staticInterfaceName(), QLatin1String("Respond"));
04152         callMessage << QVariant::fromValue(responseData);
04153         return this->connection().asyncCall(callMessage, timeout);
04154     }
04155 
04182     inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
04183     {
04184         if (!invalidationReason().isEmpty()) {
04185             return QDBusPendingReply<>(QDBusMessage::createError(
04186                 invalidationReason(),
04187                 invalidationMessage()
04188             ));
04189         }
04190 
04191         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04192                 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
04193         return this->connection().asyncCall(callMessage, timeout);
04194     }
04195 
04222     inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
04223     {
04224         if (!invalidationReason().isEmpty()) {
04225             return QDBusPendingReply<>(QDBusMessage::createError(
04226                 invalidationReason(),
04227                 invalidationMessage()
04228             ));
04229         }
04230 
04231         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04232                 this->staticInterfaceName(), QLatin1String("AbortSASL"));
04233         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
04234         return this->connection().asyncCall(callMessage, timeout);
04235     }
04236 
04237 Q_SIGNALS:
04255     void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
04256 
04274     void NewChallenge(const QByteArray& challengeData);
04275 
04276 protected:
04277     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04278 };
04279 
04287 class TELEPATHY_QT4_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
04288 {
04289     Q_OBJECT
04290 
04291 public:
04298     static inline QLatin1String staticInterfaceName()
04299     {
04300         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
04301     }
04302 
04310     ChannelInterfaceSecurableInterface(
04311         const QString& busName,
04312         const QString& objectPath,
04313         QObject* parent = 0
04314     );
04315 
04324     ChannelInterfaceSecurableInterface(
04325         const QDBusConnection& connection,
04326         const QString& busName,
04327         const QString& objectPath,
04328         QObject* parent = 0
04329     );
04330 
04337     ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
04338 
04346     explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
04347 
04355     ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04356 
04376     inline Tp::PendingVariant *requestPropertyEncrypted() const
04377     {
04378         return internalRequestProperty(QLatin1String("Encrypted"));
04379     }
04380 
04395     inline Tp::PendingVariant *requestPropertyVerified() const
04396     {
04397         return internalRequestProperty(QLatin1String("Verified"));
04398     }
04399 
04406     Tp::PendingVariantMap *requestAllProperties() const
04407     {
04408         return internalRequestAllProperties();
04409     }
04410 
04411 protected:
04412     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04413 };
04414 
04422 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
04423 {
04424     Q_OBJECT
04425 
04426 public:
04433     static inline QLatin1String staticInterfaceName()
04434     {
04435         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
04436     }
04437 
04445     ChannelInterfaceServicePointInterface(
04446         const QString& busName,
04447         const QString& objectPath,
04448         QObject* parent = 0
04449     );
04450 
04459     ChannelInterfaceServicePointInterface(
04460         const QDBusConnection& connection,
04461         const QString& busName,
04462         const QString& objectPath,
04463         QObject* parent = 0
04464     );
04465 
04472     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
04473 
04481     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
04482 
04490     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04491 
04509     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
04510     {
04511         return internalRequestProperty(QLatin1String("InitialServicePoint"));
04512     }
04513 
04526     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
04527     {
04528         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
04529     }
04530 
04537     Tp::PendingVariantMap *requestAllProperties() const
04538     {
04539         return internalRequestAllProperties();
04540     }
04541 
04542 Q_SIGNALS:
04559     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
04560 
04561 protected:
04562     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04563 };
04564 
04572 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
04573 {
04574     Q_OBJECT
04575 
04576 public:
04583     static inline QLatin1String staticInterfaceName()
04584     {
04585         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
04586     }
04587 
04595     ChannelInterfaceTubeInterface(
04596         const QString& busName,
04597         const QString& objectPath,
04598         QObject* parent = 0
04599     );
04600 
04609     ChannelInterfaceTubeInterface(
04610         const QDBusConnection& connection,
04611         const QString& busName,
04612         const QString& objectPath,
04613         QObject* parent = 0
04614     );
04615 
04622     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
04623 
04631     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
04632 
04640     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04641 
04685     inline Tp::PendingVariant *requestPropertyParameters() const
04686     {
04687         return internalRequestProperty(QLatin1String("Parameters"));
04688     }
04689 
04703     inline Tp::PendingVariant *requestPropertyState() const
04704     {
04705         return internalRequestProperty(QLatin1String("State"));
04706     }
04707 
04714     Tp::PendingVariantMap *requestAllProperties() const
04715     {
04716         return internalRequestAllProperties();
04717     }
04718 
04719 Q_SIGNALS:
04730     void TubeChannelStateChanged(uint state);
04731 
04732 protected:
04733     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04734 };
04735 
04743 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
04744 {
04745     Q_OBJECT
04746 
04747 public:
04754     static inline QLatin1String staticInterfaceName()
04755     {
04756         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
04757     }
04758 
04766     ChannelTypeContactListInterface(
04767         const QString& busName,
04768         const QString& objectPath,
04769         QObject* parent = 0
04770     );
04771 
04780     ChannelTypeContactListInterface(
04781         const QDBusConnection& connection,
04782         const QString& busName,
04783         const QString& objectPath,
04784         QObject* parent = 0
04785     );
04786 
04793     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
04794 
04802     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
04803 
04811     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04812 
04819     Tp::PendingVariantMap *requestAllProperties() const
04820     {
04821         return internalRequestAllProperties();
04822     }
04823 
04824 protected:
04825     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04826 };
04827 
04835 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
04836 {
04837     Q_OBJECT
04838 
04839 public:
04846     static inline QLatin1String staticInterfaceName()
04847     {
04848         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
04849     }
04850 
04858     ChannelTypeContactSearchInterface(
04859         const QString& busName,
04860         const QString& objectPath,
04861         QObject* parent = 0
04862     );
04863 
04872     ChannelTypeContactSearchInterface(
04873         const QDBusConnection& connection,
04874         const QString& busName,
04875         const QString& objectPath,
04876         QObject* parent = 0
04877     );
04878 
04885     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
04886 
04894     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
04895 
04903     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04904 
04915     inline Tp::PendingVariant *requestPropertySearchState() const
04916     {
04917         return internalRequestProperty(QLatin1String("SearchState"));
04918     }
04919 
04943     inline Tp::PendingVariant *requestPropertyLimit() const
04944     {
04945         return internalRequestProperty(QLatin1String("Limit"));
04946     }
04947 
04962     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
04963     {
04964         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
04965     }
04966 
04987     inline Tp::PendingVariant *requestPropertyServer() const
04988     {
04989         return internalRequestProperty(QLatin1String("Server"));
04990     }
04991 
04998     Tp::PendingVariantMap *requestAllProperties() const
04999     {
05000         return internalRequestAllProperties();
05001     }
05002 
05003 public Q_SLOTS:
05021     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
05022     {
05023         if (!invalidationReason().isEmpty()) {
05024             return QDBusPendingReply<>(QDBusMessage::createError(
05025                 invalidationReason(),
05026                 invalidationMessage()
05027             ));
05028         }
05029 
05030         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05031                 this->staticInterfaceName(), QLatin1String("Search"));
05032         callMessage << QVariant::fromValue(terms);
05033         return this->connection().asyncCall(callMessage, timeout);
05034     }
05035 
05048     inline QDBusPendingReply<> More(int timeout = -1)
05049     {
05050         if (!invalidationReason().isEmpty()) {
05051             return QDBusPendingReply<>(QDBusMessage::createError(
05052                 invalidationReason(),
05053                 invalidationMessage()
05054             ));
05055         }
05056 
05057         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05058                 this->staticInterfaceName(), QLatin1String("More"));
05059         return this->connection().asyncCall(callMessage, timeout);
05060     }
05061 
05092     inline QDBusPendingReply<> Stop(int timeout = -1)
05093     {
05094         if (!invalidationReason().isEmpty()) {
05095             return QDBusPendingReply<>(QDBusMessage::createError(
05096                 invalidationReason(),
05097                 invalidationMessage()
05098             ));
05099         }
05100 
05101         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05102                 this->staticInterfaceName(), QLatin1String("Stop"));
05103         return this->connection().asyncCall(callMessage, timeout);
05104     }
05105 
05106 Q_SIGNALS:
05150     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
05151 
05164     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
05165 
05166 protected:
05167     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05168 };
05169 
05177 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
05178 {
05179     Q_OBJECT
05180 
05181 public:
05188     static inline QLatin1String staticInterfaceName()
05189     {
05190         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
05191     }
05192 
05200     ChannelTypeFileTransferInterface(
05201         const QString& busName,
05202         const QString& objectPath,
05203         QObject* parent = 0
05204     );
05205 
05214     ChannelTypeFileTransferInterface(
05215         const QDBusConnection& connection,
05216         const QString& busName,
05217         const QString& objectPath,
05218         QObject* parent = 0
05219     );
05220 
05227     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
05228 
05236     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
05237 
05245     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05246 
05257     inline Tp::PendingVariant *requestPropertyState() const
05258     {
05259         return internalRequestProperty(QLatin1String("State"));
05260     }
05261 
05277     inline Tp::PendingVariant *requestPropertyContentType() const
05278     {
05279         return internalRequestProperty(QLatin1String("ContentType"));
05280     }
05281 
05301     inline Tp::PendingVariant *requestPropertyFilename() const
05302     {
05303         return internalRequestProperty(QLatin1String("Filename"));
05304     }
05305 
05327     inline Tp::PendingVariant *requestPropertySize() const
05328     {
05329         return internalRequestProperty(QLatin1String("Size"));
05330     }
05331 
05356     inline Tp::PendingVariant *requestPropertyContentHashType() const
05357     {
05358         return internalRequestProperty(QLatin1String("ContentHashType"));
05359     }
05360 
05379     inline Tp::PendingVariant *requestPropertyContentHash() const
05380     {
05381         return internalRequestProperty(QLatin1String("ContentHash"));
05382     }
05383 
05399     inline Tp::PendingVariant *requestPropertyDescription() const
05400     {
05401         return internalRequestProperty(QLatin1String("Description"));
05402     }
05403 
05418     inline Tp::PendingVariant *requestPropertyDate() const
05419     {
05420         return internalRequestProperty(QLatin1String("Date"));
05421     }
05422 
05449     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
05450     {
05451         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
05452     }
05453 
05465     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
05466     {
05467         return internalRequestProperty(QLatin1String("TransferredBytes"));
05468     }
05469 
05490     inline Tp::PendingVariant *requestPropertyInitialOffset() const
05491     {
05492         return internalRequestProperty(QLatin1String("InitialOffset"));
05493     }
05494 
05527     inline Tp::PendingVariant *requestPropertyURI() const
05528     {
05529         return internalRequestProperty(QLatin1String("URI"));
05530     }
05531 
05564     inline Tp::PendingOperation *setPropertyURI(QString newValue)
05565     {
05566         return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
05567     }
05568 
05575     Tp::PendingVariantMap *requestAllProperties() const
05576     {
05577         return internalRequestAllProperties();
05578     }
05579 
05580 public Q_SLOTS:
05625     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
05626     {
05627         if (!invalidationReason().isEmpty()) {
05628             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05629                 invalidationReason(),
05630                 invalidationMessage()
05631             ));
05632         }
05633 
05634         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05635                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
05636         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
05637         return this->connection().asyncCall(callMessage, timeout);
05638     }
05639 
05673     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
05674     {
05675         if (!invalidationReason().isEmpty()) {
05676             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05677                 invalidationReason(),
05678                 invalidationMessage()
05679             ));
05680         }
05681 
05682         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05683                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
05684         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05685         return this->connection().asyncCall(callMessage, timeout);
05686     }
05687 
05688 Q_SIGNALS:
05706     void FileTransferStateChanged(uint state, uint reason);
05707 
05720     void TransferredBytesChanged(qulonglong count);
05721 
05733     void InitialOffsetDefined(qulonglong initialOffset);
05734 
05746     void URIDefined(const QString& URI);
05747 
05748 protected:
05749     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05750 };
05751 
05759 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
05760 {
05761     Q_OBJECT
05762 
05763 public:
05770     static inline QLatin1String staticInterfaceName()
05771     {
05772         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
05773     }
05774 
05782     ChannelTypeRoomListInterface(
05783         const QString& busName,
05784         const QString& objectPath,
05785         QObject* parent = 0
05786     );
05787 
05796     ChannelTypeRoomListInterface(
05797         const QDBusConnection& connection,
05798         const QString& busName,
05799         const QString& objectPath,
05800         QObject* parent = 0
05801     );
05802 
05809     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
05810 
05818     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
05819 
05827     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05828 
05842     inline Tp::PendingVariant *requestPropertyServer() const
05843     {
05844         return internalRequestProperty(QLatin1String("Server"));
05845     }
05846 
05853     Tp::PendingVariantMap *requestAllProperties() const
05854     {
05855         return internalRequestAllProperties();
05856     }
05857 
05858 public Q_SLOTS:
05874     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
05875     {
05876         if (!invalidationReason().isEmpty()) {
05877             return QDBusPendingReply<bool>(QDBusMessage::createError(
05878                 invalidationReason(),
05879                 invalidationMessage()
05880             ));
05881         }
05882 
05883         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05884                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
05885         return this->connection().asyncCall(callMessage, timeout);
05886     }
05887 
05901     inline QDBusPendingReply<> ListRooms(int timeout = -1)
05902     {
05903         if (!invalidationReason().isEmpty()) {
05904             return QDBusPendingReply<>(QDBusMessage::createError(
05905                 invalidationReason(),
05906                 invalidationMessage()
05907             ));
05908         }
05909 
05910         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05911                 this->staticInterfaceName(), QLatin1String("ListRooms"));
05912         return this->connection().asyncCall(callMessage, timeout);
05913     }
05914 
05927     inline QDBusPendingReply<> StopListing(int timeout = -1)
05928     {
05929         if (!invalidationReason().isEmpty()) {
05930             return QDBusPendingReply<>(QDBusMessage::createError(
05931                 invalidationReason(),
05932                 invalidationMessage()
05933             ));
05934         }
05935 
05936         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05937                 this->staticInterfaceName(), QLatin1String("StopListing"));
05938         return this->connection().asyncCall(callMessage, timeout);
05939     }
05940 
05941 Q_SIGNALS:
05995     void GotRooms(const Tp::RoomInfoList& rooms);
05996 
06007     void ListingRooms(bool listing);
06008 
06009 protected:
06010     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06011 };
06012 
06020 class TELEPATHY_QT4_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
06021 {
06022     Q_OBJECT
06023 
06024 public:
06031     static inline QLatin1String staticInterfaceName()
06032     {
06033         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
06034     }
06035 
06043     ChannelTypeServerAuthenticationInterface(
06044         const QString& busName,
06045         const QString& objectPath,
06046         QObject* parent = 0
06047     );
06048 
06057     ChannelTypeServerAuthenticationInterface(
06058         const QDBusConnection& connection,
06059         const QString& busName,
06060         const QString& objectPath,
06061         QObject* parent = 0
06062     );
06063 
06070     ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
06071 
06079     explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
06080 
06088     ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06089 
06104     inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
06105     {
06106         return internalRequestProperty(QLatin1String("AuthenticationMethod"));
06107     }
06108 
06115     Tp::PendingVariantMap *requestAllProperties() const
06116     {
06117         return internalRequestAllProperties();
06118     }
06119 
06120 protected:
06121     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06122 };
06123 
06131 class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
06132 {
06133     Q_OBJECT
06134 
06135 public:
06142     static inline QLatin1String staticInterfaceName()
06143     {
06144         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
06145     }
06146 
06154     ChannelTypeServerTLSConnectionInterface(
06155         const QString& busName,
06156         const QString& objectPath,
06157         QObject* parent = 0
06158     );
06159 
06168     ChannelTypeServerTLSConnectionInterface(
06169         const QDBusConnection& connection,
06170         const QString& busName,
06171         const QString& objectPath,
06172         QObject* parent = 0
06173     );
06174 
06181     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
06182 
06190     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
06191 
06199     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06200 
06211     inline Tp::PendingVariant *requestPropertyServerCertificate() const
06212     {
06213         return internalRequestProperty(QLatin1String("ServerCertificate"));
06214     }
06215 
06229     inline Tp::PendingVariant *requestPropertyHostname() const
06230     {
06231         return internalRequestProperty(QLatin1String("Hostname"));
06232     }
06233 
06260     inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
06261     {
06262         return internalRequestProperty(QLatin1String("ReferenceIdentities"));
06263     }
06264 
06271     Tp::PendingVariantMap *requestAllProperties() const
06272     {
06273         return internalRequestAllProperties();
06274     }
06275 
06276 protected:
06277     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06278 };
06279 
06287 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
06288 {
06289     Q_OBJECT
06290 
06291 public:
06298     static inline QLatin1String staticInterfaceName()
06299     {
06300         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
06301     }
06302 
06310     ChannelTypeStreamTubeInterface(
06311         const QString& busName,
06312         const QString& objectPath,
06313         QObject* parent = 0
06314     );
06315 
06324     ChannelTypeStreamTubeInterface(
06325         const QDBusConnection& connection,
06326         const QString& busName,
06327         const QString& objectPath,
06328         QObject* parent = 0
06329     );
06330 
06337     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
06338 
06346     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
06347 
06355     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06356 
06377     inline Tp::PendingVariant *requestPropertyService() const
06378     {
06379         return internalRequestProperty(QLatin1String("Service"));
06380     }
06381 
06414     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
06415     {
06416         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
06417     }
06418 
06425     Tp::PendingVariantMap *requestAllProperties() const
06426     {
06427         return internalRequestAllProperties();
06428     }
06429 
06430 public Q_SLOTS:
06461     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
06462     {
06463         if (!invalidationReason().isEmpty()) {
06464             return QDBusPendingReply<>(QDBusMessage::createError(
06465                 invalidationReason(),
06466                 invalidationMessage()
06467             ));
06468         }
06469 
06470         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06471                 this->staticInterfaceName(), QLatin1String("Offer"));
06472         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
06473         return this->connection().asyncCall(callMessage, timeout);
06474     }
06475 
06514     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
06515     {
06516         if (!invalidationReason().isEmpty()) {
06517             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06518                 invalidationReason(),
06519                 invalidationMessage()
06520             ));
06521         }
06522 
06523         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06524                 this->staticInterfaceName(), QLatin1String("Accept"));
06525         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
06526         return this->connection().asyncCall(callMessage, timeout);
06527     }
06528 
06529 Q_SIGNALS:
06566     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
06567 
06581     void NewLocalConnection(uint connectionID);
06582 
06610     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
06611 
06612 protected:
06613     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06614 };
06615 
06623 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
06624 {
06625     Q_OBJECT
06626 
06627 public:
06634     static inline QLatin1String staticInterfaceName()
06635     {
06636         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
06637     }
06638 
06646     ChannelTypeStreamedMediaInterface(
06647         const QString& busName,
06648         const QString& objectPath,
06649         QObject* parent = 0
06650     );
06651 
06660     ChannelTypeStreamedMediaInterface(
06661         const QDBusConnection& connection,
06662         const QString& busName,
06663         const QString& objectPath,
06664         QObject* parent = 0
06665     );
06666 
06673     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
06674 
06682     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
06683 
06691     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06692 
06779     inline Tp::PendingVariant *requestPropertyInitialAudio() const
06780     {
06781         return internalRequestProperty(QLatin1String("InitialAudio"));
06782     }
06783 
06802     inline Tp::PendingVariant *requestPropertyInitialVideo() const
06803     {
06804         return internalRequestProperty(QLatin1String("InitialVideo"));
06805     }
06806 
06847     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
06848     {
06849         return internalRequestProperty(QLatin1String("ImmutableStreams"));
06850     }
06851 
06858     Tp::PendingVariantMap *requestAllProperties() const
06859     {
06860         return internalRequestAllProperties();
06861     }
06862 
06863 public Q_SLOTS:
06889     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
06890     {
06891         if (!invalidationReason().isEmpty()) {
06892             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
06893                 invalidationReason(),
06894                 invalidationMessage()
06895             ));
06896         }
06897 
06898         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06899                 this->staticInterfaceName(), QLatin1String("ListStreams"));
06900         return this->connection().asyncCall(callMessage, timeout);
06901     }
06902 
06927     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
06928     {
06929         if (!invalidationReason().isEmpty()) {
06930             return QDBusPendingReply<>(QDBusMessage::createError(
06931                 invalidationReason(),
06932                 invalidationMessage()
06933             ));
06934         }
06935 
06936         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06937                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
06938         callMessage << QVariant::fromValue(streams);
06939         return this->connection().asyncCall(callMessage, timeout);
06940     }
06941 
06976     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
06977     {
06978         if (!invalidationReason().isEmpty()) {
06979             return QDBusPendingReply<>(QDBusMessage::createError(
06980                 invalidationReason(),
06981                 invalidationMessage()
06982             ));
06983         }
06984 
06985         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06986                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
06987         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
06988         return this->connection().asyncCall(callMessage, timeout);
06989     }
06990 
07039     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
07040     {
07041         if (!invalidationReason().isEmpty()) {
07042             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
07043                 invalidationReason(),
07044                 invalidationMessage()
07045             ));
07046         }
07047 
07048         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07049                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
07050         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
07051         return this->connection().asyncCall(callMessage, timeout);
07052     }
07053 
07054 Q_SIGNALS:
07119     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
07120 
07150     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
07151 
07169     void StreamError(uint streamID, uint errorCode, const QString& message);
07170 
07180     void StreamRemoved(uint streamID);
07181 
07195     void StreamStateChanged(uint streamID, uint streamState);
07196 
07197 protected:
07198     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07199 };
07200 
07208 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
07209 {
07210     Q_OBJECT
07211 
07212 public:
07219     static inline QLatin1String staticInterfaceName()
07220     {
07221         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
07222     }
07223 
07231     ChannelTypeTextInterface(
07232         const QString& busName,
07233         const QString& objectPath,
07234         QObject* parent = 0
07235     );
07236 
07245     ChannelTypeTextInterface(
07246         const QDBusConnection& connection,
07247         const QString& busName,
07248         const QString& objectPath,
07249         QObject* parent = 0
07250     );
07251 
07258     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
07259 
07267     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
07268 
07276     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07277 
07284     Tp::PendingVariantMap *requestAllProperties() const
07285     {
07286         return internalRequestAllProperties();
07287     }
07288 
07289 public Q_SLOTS:
07305     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
07306     {
07307         if (!invalidationReason().isEmpty()) {
07308             return QDBusPendingReply<>(QDBusMessage::createError(
07309                 invalidationReason(),
07310                 invalidationMessage()
07311             ));
07312         }
07313 
07314         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07315                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
07316         callMessage << QVariant::fromValue(IDs);
07317         return this->connection().asyncCall(callMessage, timeout);
07318     }
07319 
07335     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
07336     {
07337         if (!invalidationReason().isEmpty()) {
07338             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
07339                 invalidationReason(),
07340                 invalidationMessage()
07341             ));
07342         }
07343 
07344         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07345                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
07346         return this->connection().asyncCall(callMessage, timeout);
07347     }
07348 
07377     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
07378     {
07379         if (!invalidationReason().isEmpty()) {
07380             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
07381                 invalidationReason(),
07382                 invalidationMessage()
07383             ));
07384         }
07385 
07386         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07387                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
07388         callMessage << QVariant::fromValue(clear);
07389         return this->connection().asyncCall(callMessage, timeout);
07390     }
07391 
07422     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
07423     {
07424         if (!invalidationReason().isEmpty()) {
07425             return QDBusPendingReply<>(QDBusMessage::createError(
07426                 invalidationReason(),
07427                 invalidationMessage()
07428             ));
07429         }
07430 
07431         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07432                 this->staticInterfaceName(), QLatin1String("Send"));
07433         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
07434         return this->connection().asyncCall(callMessage, timeout);
07435     }
07436 
07437 Q_SIGNALS:
07445     void LostMessage();
07446 
07480     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
07481 
07508     void SendError(uint error, uint timestamp, uint type, const QString& text);
07509 
07531     void Sent(uint timestamp, uint type, const QString& text);
07532 
07533 protected:
07534     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07535 };
07536 
07544 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
07545 {
07546     Q_OBJECT
07547 
07548 public:
07555     static inline QLatin1String staticInterfaceName()
07556     {
07557         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
07558     }
07559 
07567     ChannelTypeTubesInterface(
07568         const QString& busName,
07569         const QString& objectPath,
07570         QObject* parent = 0
07571     );
07572 
07581     ChannelTypeTubesInterface(
07582         const QDBusConnection& connection,
07583         const QString& busName,
07584         const QString& objectPath,
07585         QObject* parent = 0
07586     );
07587 
07594     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
07595 
07603     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
07604 
07612     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07613 
07620     Tp::PendingVariantMap *requestAllProperties() const
07621     {
07622         return internalRequestAllProperties();
07623     }
07624 
07625 public Q_SLOTS:
07660     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
07661     {
07662         if (!invalidationReason().isEmpty()) {
07663             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
07664                 invalidationReason(),
07665                 invalidationMessage()
07666             ));
07667         }
07668 
07669         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07670                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
07671         return this->connection().asyncCall(callMessage, timeout);
07672     }
07673 
07687     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
07688     {
07689         if (!invalidationReason().isEmpty()) {
07690             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
07691                 invalidationReason(),
07692                 invalidationMessage()
07693             ));
07694         }
07695 
07696         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07697                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
07698         return this->connection().asyncCall(callMessage, timeout);
07699     }
07700 
07716     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
07717     {
07718         if (!invalidationReason().isEmpty()) {
07719             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
07720                 invalidationReason(),
07721                 invalidationMessage()
07722             ));
07723         }
07724 
07725         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07726                 this->staticInterfaceName(), QLatin1String("ListTubes"));
07727         return this->connection().asyncCall(callMessage, timeout);
07728     }
07729 
07757     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
07758     {
07759         if (!invalidationReason().isEmpty()) {
07760             return QDBusPendingReply<uint>(QDBusMessage::createError(
07761                 invalidationReason(),
07762                 invalidationMessage()
07763             ));
07764         }
07765 
07766         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07767                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
07768         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
07769         return this->connection().asyncCall(callMessage, timeout);
07770     }
07771 
07827     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
07828     {
07829         if (!invalidationReason().isEmpty()) {
07830             return QDBusPendingReply<uint>(QDBusMessage::createError(
07831                 invalidationReason(),
07832                 invalidationMessage()
07833             ));
07834         }
07835 
07836         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07837                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
07838         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
07839         return this->connection().asyncCall(callMessage, timeout);
07840     }
07841 
07864     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
07865     {
07866         if (!invalidationReason().isEmpty()) {
07867             return QDBusPendingReply<QString>(QDBusMessage::createError(
07868                 invalidationReason(),
07869                 invalidationMessage()
07870             ));
07871         }
07872 
07873         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07874                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
07875         callMessage << QVariant::fromValue(ID);
07876         return this->connection().asyncCall(callMessage, timeout);
07877     }
07878 
07916     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
07917     {
07918         if (!invalidationReason().isEmpty()) {
07919             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
07920                 invalidationReason(),
07921                 invalidationMessage()
07922             ));
07923         }
07924 
07925         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07926                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
07927         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
07928         return this->connection().asyncCall(callMessage, timeout);
07929     }
07930 
07945     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
07946     {
07947         if (!invalidationReason().isEmpty()) {
07948             return QDBusPendingReply<>(QDBusMessage::createError(
07949                 invalidationReason(),
07950                 invalidationMessage()
07951             ));
07952         }
07953 
07954         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07955                 this->staticInterfaceName(), QLatin1String("CloseTube"));
07956         callMessage << QVariant::fromValue(ID);
07957         return this->connection().asyncCall(callMessage, timeout);
07958     }
07959 
07979     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
07980     {
07981         if (!invalidationReason().isEmpty()) {
07982             return QDBusPendingReply<QString>(QDBusMessage::createError(
07983                 invalidationReason(),
07984                 invalidationMessage()
07985             ));
07986         }
07987 
07988         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07989                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
07990         callMessage << QVariant::fromValue(ID);
07991         return this->connection().asyncCall(callMessage, timeout);
07992     }
07993 
08014     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
08015     {
08016         if (!invalidationReason().isEmpty()) {
08017             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
08018                 invalidationReason(),
08019                 invalidationMessage()
08020             ));
08021         }
08022 
08023         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08024                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
08025         callMessage << QVariant::fromValue(ID);
08026         return this->connection().asyncCall(callMessage, timeout);
08027     }
08028 
08054     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
08055     {
08056         if (!invalidationReason().isEmpty()) {
08057             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
08058                 invalidationReason(),
08059                 invalidationMessage()
08060             ));
08061         }
08062 
08063         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08064                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
08065         callMessage << QVariant::fromValue(ID);
08066         return this->connection().asyncCall(callMessage, timeout);
08067     }
08068 
08069 Q_SIGNALS:
08099     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
08100 
08114     void TubeStateChanged(uint ID, uint state);
08115 
08126     void TubeClosed(uint ID);
08127 
08146     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
08147 
08162     void StreamTubeNewConnection(uint ID, uint handle);
08163 
08164 protected:
08165     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08166 };
08167 }
08168 }
08169 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
08170 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
08171 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
08172 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
08173 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
08174 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
08175 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
08176 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
08177 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
08178 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
08179 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
08180 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
08181 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
08182 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
08183 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
08184 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
08185 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
08186 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
08187 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
08188 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
08189 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
08190 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
08191 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
08192 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
08193 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


Copyright © 2008-2011 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.6.1