Home · All Classes · All Namespaces · Modules · Functions · Files
cli-channel.h
00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt-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_TP_QT_HEADER
00009 #error IN_TP_QT_HEADER
00010 #endif
00011 
00012 #include <TelepathyQt/Types>
00013 
00014 #include <QtGlobal>
00015 
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019 
00020 #include <QDBusPendingReply>
00021 
00022 #include <TelepathyQt/AbstractInterface>
00023 #include <TelepathyQt/DBusProxy>
00024 #include <TelepathyQt/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 TP_QT_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 
00126     inline Tp::PendingVariant *requestPropertyChannelType() const
00127     {
00128         return internalRequestProperty(QLatin1String("ChannelType"));
00129     }
00130 
00164     inline Tp::PendingVariant *requestPropertyInterfaces() const
00165     {
00166         return internalRequestProperty(QLatin1String("Interfaces"));
00167     }
00168 
00213     inline Tp::PendingVariant *requestPropertyTargetHandle() const
00214     {
00215         return internalRequestProperty(QLatin1String("TargetHandle"));
00216     }
00217 
00271     inline Tp::PendingVariant *requestPropertyTargetID() const
00272     {
00273         return internalRequestProperty(QLatin1String("TargetID"));
00274     }
00275 
00295     inline Tp::PendingVariant *requestPropertyTargetHandleType() const
00296     {
00297         return internalRequestProperty(QLatin1String("TargetHandleType"));
00298     }
00299 
00368     inline Tp::PendingVariant *requestPropertyRequested() const
00369     {
00370         return internalRequestProperty(QLatin1String("Requested"));
00371     }
00372 
00434     inline Tp::PendingVariant *requestPropertyInitiatorHandle() const
00435     {
00436         return internalRequestProperty(QLatin1String("InitiatorHandle"));
00437     }
00438 
00473     inline Tp::PendingVariant *requestPropertyInitiatorID() const
00474     {
00475         return internalRequestProperty(QLatin1String("InitiatorID"));
00476     }
00477 
00484     Tp::PendingVariantMap *requestAllProperties() const
00485     {
00486         return internalRequestAllProperties();
00487     }
00488 
00489 public Q_SLOTS:
00504     inline QDBusPendingReply<> Close(int timeout = -1)
00505     {
00506         if (!invalidationReason().isEmpty()) {
00507             return QDBusPendingReply<>(QDBusMessage::createError(
00508                 invalidationReason(),
00509                 invalidationMessage()
00510             ));
00511         }
00512 
00513         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00514                 this->staticInterfaceName(), QLatin1String("Close"));
00515         return this->connection().asyncCall(callMessage, timeout);
00516     }
00517 
00535     inline QDBusPendingReply<QString> GetChannelType(int timeout = -1)
00536     {
00537         if (!invalidationReason().isEmpty()) {
00538             return QDBusPendingReply<QString>(QDBusMessage::createError(
00539                 invalidationReason(),
00540                 invalidationMessage()
00541             ));
00542         }
00543 
00544         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00545                 this->staticInterfaceName(), QLatin1String("GetChannelType"));
00546         return this->connection().asyncCall(callMessage, timeout);
00547     }
00548 
00572     inline QDBusPendingReply<uint, uint> GetHandle(int timeout = -1)
00573     {
00574         if (!invalidationReason().isEmpty()) {
00575             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00576                 invalidationReason(),
00577                 invalidationMessage()
00578             ));
00579         }
00580 
00581         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00582                 this->staticInterfaceName(), QLatin1String("GetHandle"));
00583         return this->connection().asyncCall(callMessage, timeout);
00584     }
00585 
00603     inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00604     {
00605         if (!invalidationReason().isEmpty()) {
00606             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00607                 invalidationReason(),
00608                 invalidationMessage()
00609             ));
00610         }
00611 
00612         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00613                 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00614         return this->connection().asyncCall(callMessage, timeout);
00615     }
00616 
00617 Q_SIGNALS:
00625     void Closed();
00626 
00627 protected:
00628     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00629 };
00630 
00638 class TP_QT_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
00639 {
00640     Q_OBJECT
00641 
00642 public:
00649     static inline QLatin1String staticInterfaceName()
00650     {
00651         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Anonymity");
00652     }
00653 
00661     ChannelInterfaceAnonymityInterface(
00662         const QString& busName,
00663         const QString& objectPath,
00664         QObject* parent = 0
00665     );
00666 
00675     ChannelInterfaceAnonymityInterface(
00676         const QDBusConnection& connection,
00677         const QString& busName,
00678         const QString& objectPath,
00679         QObject* parent = 0
00680     );
00681 
00688     ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00689 
00697     explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);
00698 
00706     ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00707 
00720     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
00721     {
00722         return internalRequestProperty(QLatin1String("AnonymityModes"));
00723     }
00724 
00735     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
00736     {
00737         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
00738     }
00739 
00761     inline Tp::PendingVariant *requestPropertyAnonymousID() const
00762     {
00763         return internalRequestProperty(QLatin1String("AnonymousID"));
00764     }
00765 
00772     Tp::PendingVariantMap *requestAllProperties() const
00773     {
00774         return internalRequestAllProperties();
00775     }
00776 
00777 protected:
00778     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00779 };
00780 
00788 class TP_QT_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00789 {
00790     Q_OBJECT
00791 
00792 public:
00799     static inline QLatin1String staticInterfaceName()
00800     {
00801         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.CallState");
00802     }
00803 
00811     ChannelInterfaceCallStateInterface(
00812         const QString& busName,
00813         const QString& objectPath,
00814         QObject* parent = 0
00815     );
00816 
00825     ChannelInterfaceCallStateInterface(
00826         const QDBusConnection& connection,
00827         const QString& busName,
00828         const QString& objectPath,
00829         QObject* parent = 0
00830     );
00831 
00838     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00839 
00847     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00848 
00856     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00857 
00864     Tp::PendingVariantMap *requestAllProperties() const
00865     {
00866         return internalRequestAllProperties();
00867     }
00868 
00869 public Q_SLOTS:
00885     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates(int timeout = -1)
00886     {
00887         if (!invalidationReason().isEmpty()) {
00888             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00889                 invalidationReason(),
00890                 invalidationMessage()
00891             ));
00892         }
00893 
00894         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00895                 this->staticInterfaceName(), QLatin1String("GetCallStates"));
00896         return this->connection().asyncCall(callMessage, timeout);
00897     }
00898 
00899 Q_SIGNALS:
00913     void CallStateChanged(uint contact, uint state);
00914 
00915 protected:
00916     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00917 };
00918 
00926 class TP_QT_EXPORT ChannelInterfaceCaptchaAuthenticationInterface : public Tp::AbstractInterface
00927 {
00928     Q_OBJECT
00929 
00930 public:
00937     static inline QLatin1String staticInterfaceName()
00938     {
00939         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.CaptchaAuthentication1");
00940     }
00941 
00949     ChannelInterfaceCaptchaAuthenticationInterface(
00950         const QString& busName,
00951         const QString& objectPath,
00952         QObject* parent = 0
00953     );
00954 
00963     ChannelInterfaceCaptchaAuthenticationInterface(
00964         const QDBusConnection& connection,
00965         const QString& busName,
00966         const QString& objectPath,
00967         QObject* parent = 0
00968     );
00969 
00976     ChannelInterfaceCaptchaAuthenticationInterface(Tp::DBusProxy *proxy);
00977 
00985     explicit ChannelInterfaceCaptchaAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
00986 
00994     ChannelInterfaceCaptchaAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00995 
01017     inline Tp::PendingVariant *requestPropertyCanRetryCaptcha() const
01018     {
01019         return internalRequestProperty(QLatin1String("CanRetryCaptcha"));
01020     }
01021 
01047     inline Tp::PendingVariant *requestPropertyCaptchaStatus() const
01048     {
01049         return internalRequestProperty(QLatin1String("CaptchaStatus"));
01050     }
01051 
01085     inline Tp::PendingVariant *requestPropertyCaptchaError() const
01086     {
01087         return internalRequestProperty(QLatin1String("CaptchaError"));
01088     }
01089 
01111     inline Tp::PendingVariant *requestPropertyCaptchaErrorDetails() const
01112     {
01113         return internalRequestProperty(QLatin1String("CaptchaErrorDetails"));
01114     }
01115 
01122     Tp::PendingVariantMap *requestAllProperties() const
01123     {
01124         return internalRequestAllProperties();
01125     }
01126 
01127 public Q_SLOTS:
01181     inline QDBusPendingReply<Tp::CaptchaInfoList, uint, QString> GetCaptchas(int timeout = -1)
01182     {
01183         if (!invalidationReason().isEmpty()) {
01184             return QDBusPendingReply<Tp::CaptchaInfoList, uint, QString>(QDBusMessage::createError(
01185                 invalidationReason(),
01186                 invalidationMessage()
01187             ));
01188         }
01189 
01190         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01191                 this->staticInterfaceName(), QLatin1String("GetCaptchas"));
01192         return this->connection().asyncCall(callMessage, timeout);
01193     }
01194 
01232     inline QDBusPendingReply<QByteArray> GetCaptchaData(uint ID, const QString& mimeType, int timeout = -1)
01233     {
01234         if (!invalidationReason().isEmpty()) {
01235             return QDBusPendingReply<QByteArray>(QDBusMessage::createError(
01236                 invalidationReason(),
01237                 invalidationMessage()
01238             ));
01239         }
01240 
01241         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01242                 this->staticInterfaceName(), QLatin1String("GetCaptchaData"));
01243         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(mimeType);
01244         return this->connection().asyncCall(callMessage, timeout);
01245     }
01246 
01265     inline QDBusPendingReply<> AnswerCaptchas(const Tp::CaptchaAnswers& answers, int timeout = -1)
01266     {
01267         if (!invalidationReason().isEmpty()) {
01268             return QDBusPendingReply<>(QDBusMessage::createError(
01269                 invalidationReason(),
01270                 invalidationMessage()
01271             ));
01272         }
01273 
01274         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01275                 this->staticInterfaceName(), QLatin1String("AnswerCaptchas"));
01276         callMessage << QVariant::fromValue(answers);
01277         return this->connection().asyncCall(callMessage, timeout);
01278     }
01279 
01307     inline QDBusPendingReply<> CancelCaptcha(uint reason, const QString& debugMessage, int timeout = -1)
01308     {
01309         if (!invalidationReason().isEmpty()) {
01310             return QDBusPendingReply<>(QDBusMessage::createError(
01311                 invalidationReason(),
01312                 invalidationMessage()
01313             ));
01314         }
01315 
01316         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01317                 this->staticInterfaceName(), QLatin1String("CancelCaptcha"));
01318         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
01319         return this->connection().asyncCall(callMessage, timeout);
01320     }
01321 
01322 protected:
01323     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01324 };
01325 
01333 class TP_QT_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
01334 {
01335     Q_OBJECT
01336 
01337 public:
01344     static inline QLatin1String staticInterfaceName()
01345     {
01346         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ChatState");
01347     }
01348 
01356     ChannelInterfaceChatStateInterface(
01357         const QString& busName,
01358         const QString& objectPath,
01359         QObject* parent = 0
01360     );
01361 
01370     ChannelInterfaceChatStateInterface(
01371         const QDBusConnection& connection,
01372         const QString& busName,
01373         const QString& objectPath,
01374         QObject* parent = 0
01375     );
01376 
01383     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
01384 
01392     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
01393 
01401     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01402 
01438     inline Tp::PendingVariant *requestPropertyChatStates() const
01439     {
01440         return internalRequestProperty(QLatin1String("ChatStates"));
01441     }
01442 
01449     Tp::PendingVariantMap *requestAllProperties() const
01450     {
01451         return internalRequestAllProperties();
01452     }
01453 
01454 public Q_SLOTS:
01470     inline QDBusPendingReply<> SetChatState(uint state, int timeout = -1)
01471     {
01472         if (!invalidationReason().isEmpty()) {
01473             return QDBusPendingReply<>(QDBusMessage::createError(
01474                 invalidationReason(),
01475                 invalidationMessage()
01476             ));
01477         }
01478 
01479         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01480                 this->staticInterfaceName(), QLatin1String("SetChatState"));
01481         callMessage << QVariant::fromValue(state);
01482         return this->connection().asyncCall(callMessage, timeout);
01483     }
01484 
01485 Q_SIGNALS:
01500     void ChatStateChanged(uint contact, uint state);
01501 
01502 protected:
01503     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01504 };
01505 
01513 class TP_QT_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
01514 {
01515     Q_OBJECT
01516 
01517 public:
01524     static inline QLatin1String staticInterfaceName()
01525     {
01526         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Conference");
01527     }
01528 
01536     ChannelInterfaceConferenceInterface(
01537         const QString& busName,
01538         const QString& objectPath,
01539         QObject* parent = 0
01540     );
01541 
01550     ChannelInterfaceConferenceInterface(
01551         const QDBusConnection& connection,
01552         const QString& busName,
01553         const QString& objectPath,
01554         QObject* parent = 0
01555     );
01556 
01563     ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
01564 
01572     explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
01573 
01581     ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01582 
01611     inline Tp::PendingVariant *requestPropertyChannels() const
01612     {
01613         return internalRequestProperty(QLatin1String("Channels"));
01614     }
01615 
01677     inline Tp::PendingVariant *requestPropertyInitialChannels() const
01678     {
01679         return internalRequestProperty(QLatin1String("InitialChannels"));
01680     }
01681 
01755     inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
01756     {
01757         return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
01758     }
01759 
01784     inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
01785     {
01786         return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
01787     }
01788 
01816     inline Tp::PendingVariant *requestPropertyInvitationMessage() const
01817     {
01818         return internalRequestProperty(QLatin1String("InvitationMessage"));
01819     }
01820 
01886     inline Tp::PendingVariant *requestPropertyOriginalChannels() const
01887     {
01888         return internalRequestProperty(QLatin1String("OriginalChannels"));
01889     }
01890 
01897     Tp::PendingVariantMap *requestAllProperties() const
01898     {
01899         return internalRequestAllProperties();
01900     }
01901 
01902 Q_SIGNALS:
01926     void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01927 
01952     void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01953 
01954 protected:
01955     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01956 };
01957 
01965 class TP_QT_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01966 {
01967     Q_OBJECT
01968 
01969 public:
01976     static inline QLatin1String staticInterfaceName()
01977     {
01978         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
01979     }
01980 
01988     ChannelInterfaceDTMFInterface(
01989         const QString& busName,
01990         const QString& objectPath,
01991         QObject* parent = 0
01992     );
01993 
02002     ChannelInterfaceDTMFInterface(
02003         const QDBusConnection& connection,
02004         const QString& busName,
02005         const QString& objectPath,
02006         QObject* parent = 0
02007     );
02008 
02015     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
02016 
02024     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
02025 
02033     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02034 
02046     inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
02047     {
02048         return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
02049     }
02050 
02064     inline Tp::PendingVariant *requestPropertyInitialTones() const
02065     {
02066         return internalRequestProperty(QLatin1String("InitialTones"));
02067     }
02068 
02086     inline Tp::PendingVariant *requestPropertyDeferredTones() const
02087     {
02088         return internalRequestProperty(QLatin1String("DeferredTones"));
02089     }
02090 
02097     Tp::PendingVariantMap *requestAllProperties() const
02098     {
02099         return internalRequestAllProperties();
02100     }
02101 
02102 public Q_SLOTS:
02133     inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
02134     {
02135         if (!invalidationReason().isEmpty()) {
02136             return QDBusPendingReply<>(QDBusMessage::createError(
02137                 invalidationReason(),
02138                 invalidationMessage()
02139             ));
02140         }
02141 
02142         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02143                 this->staticInterfaceName(), QLatin1String("StartTone"));
02144         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
02145         return this->connection().asyncCall(callMessage, timeout);
02146     }
02147 
02170     inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
02171     {
02172         if (!invalidationReason().isEmpty()) {
02173             return QDBusPendingReply<>(QDBusMessage::createError(
02174                 invalidationReason(),
02175                 invalidationMessage()
02176             ));
02177         }
02178 
02179         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02180                 this->staticInterfaceName(), QLatin1String("StopTone"));
02181         callMessage << QVariant::fromValue(streamID);
02182         return this->connection().asyncCall(callMessage, timeout);
02183     }
02184 
02230     inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
02231     {
02232         if (!invalidationReason().isEmpty()) {
02233             return QDBusPendingReply<>(QDBusMessage::createError(
02234                 invalidationReason(),
02235                 invalidationMessage()
02236             ));
02237         }
02238 
02239         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02240                 this->staticInterfaceName(), QLatin1String("MultipleTones"));
02241         callMessage << QVariant::fromValue(tones);
02242         return this->connection().asyncCall(callMessage, timeout);
02243     }
02244 
02245 Q_SIGNALS:
02273     void TonesDeferred(const QString& tones);
02274 
02291     void SendingTones(const QString& tones);
02292 
02304     void StoppedTones(bool cancelled);
02305 
02306 protected:
02307     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02308 };
02309 
02317 class TP_QT_EXPORT ChannelInterfaceDestroyableInterface : public Tp::AbstractInterface
02318 {
02319     Q_OBJECT
02320 
02321 public:
02328     static inline QLatin1String staticInterfaceName()
02329     {
02330         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Destroyable");
02331     }
02332 
02340     ChannelInterfaceDestroyableInterface(
02341         const QString& busName,
02342         const QString& objectPath,
02343         QObject* parent = 0
02344     );
02345 
02354     ChannelInterfaceDestroyableInterface(
02355         const QDBusConnection& connection,
02356         const QString& busName,
02357         const QString& objectPath,
02358         QObject* parent = 0
02359     );
02360 
02367     ChannelInterfaceDestroyableInterface(Tp::DBusProxy *proxy);
02368 
02376     explicit ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface);
02377 
02385     ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02386 
02393     Tp::PendingVariantMap *requestAllProperties() const
02394     {
02395         return internalRequestAllProperties();
02396     }
02397 
02398 public Q_SLOTS:
02443     inline QDBusPendingReply<> Destroy(int timeout = -1)
02444     {
02445         if (!invalidationReason().isEmpty()) {
02446             return QDBusPendingReply<>(QDBusMessage::createError(
02447                 invalidationReason(),
02448                 invalidationMessage()
02449             ));
02450         }
02451 
02452         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02453                 this->staticInterfaceName(), QLatin1String("Destroy"));
02454         return this->connection().asyncCall(callMessage, timeout);
02455     }
02456 
02457 protected:
02458     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02459 };
02460 
02468 class TP_QT_EXPORT ChannelInterfaceFileTransferMetadataInterface : public Tp::AbstractInterface
02469 {
02470     Q_OBJECT
02471 
02472 public:
02479     static inline QLatin1String staticInterfaceName()
02480     {
02481         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.FileTransfer.Metadata");
02482     }
02483 
02491     ChannelInterfaceFileTransferMetadataInterface(
02492         const QString& busName,
02493         const QString& objectPath,
02494         QObject* parent = 0
02495     );
02496 
02505     ChannelInterfaceFileTransferMetadataInterface(
02506         const QDBusConnection& connection,
02507         const QString& busName,
02508         const QString& objectPath,
02509         QObject* parent = 0
02510     );
02511 
02518     ChannelInterfaceFileTransferMetadataInterface(Tp::DBusProxy *proxy);
02519 
02527     explicit ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface);
02528 
02536     ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02537 
02554     inline Tp::PendingVariant *requestPropertyServiceName() const
02555     {
02556         return internalRequestProperty(QLatin1String("ServiceName"));
02557     }
02558 
02575     inline Tp::PendingOperation *setPropertyServiceName(QString newValue)
02576     {
02577         return internalSetProperty(QLatin1String("ServiceName"), QVariant::fromValue(newValue));
02578     }
02579 
02593     inline Tp::PendingVariant *requestPropertyMetadata() const
02594     {
02595         return internalRequestProperty(QLatin1String("Metadata"));
02596     }
02597 
02611     inline Tp::PendingOperation *setPropertyMetadata(Tp::Metadata newValue)
02612     {
02613         return internalSetProperty(QLatin1String("Metadata"), QVariant::fromValue(newValue));
02614     }
02615 
02622     Tp::PendingVariantMap *requestAllProperties() const
02623     {
02624         return internalRequestAllProperties();
02625     }
02626 
02627 protected:
02628     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02629 };
02630 
02638 class TP_QT_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
02639 {
02640     Q_OBJECT
02641 
02642 public:
02649     static inline QLatin1String staticInterfaceName()
02650     {
02651         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
02652     }
02653 
02661     ChannelInterfaceGroupInterface(
02662         const QString& busName,
02663         const QString& objectPath,
02664         QObject* parent = 0
02665     );
02666 
02675     ChannelInterfaceGroupInterface(
02676         const QDBusConnection& connection,
02677         const QString& busName,
02678         const QString& objectPath,
02679         QObject* parent = 0
02680     );
02681 
02688     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
02689 
02697     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
02698 
02706     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02707 
02720     inline Tp::PendingVariant *requestPropertyGroupFlags() const
02721     {
02722         return internalRequestProperty(QLatin1String("GroupFlags"));
02723     }
02724 
02740     inline Tp::PendingVariant *requestPropertyHandleOwners() const
02741     {
02742         return internalRequestProperty(QLatin1String("HandleOwners"));
02743     }
02744 
02755     inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
02756     {
02757         return internalRequestProperty(QLatin1String("LocalPendingMembers"));
02758     }
02759 
02769     inline Tp::PendingVariant *requestPropertyMembers() const
02770     {
02771         return internalRequestProperty(QLatin1String("Members"));
02772     }
02773 
02784     inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
02785     {
02786         return internalRequestProperty(QLatin1String("RemotePendingMembers"));
02787     }
02788 
02803     inline Tp::PendingVariant *requestPropertySelfHandle() const
02804     {
02805         return internalRequestProperty(QLatin1String("SelfHandle"));
02806     }
02807 
02821     inline Tp::PendingVariant *requestPropertyMemberIdentifiers() const
02822     {
02823         return internalRequestProperty(QLatin1String("MemberIdentifiers"));
02824     }
02825 
02832     Tp::PendingVariantMap *requestAllProperties() const
02833     {
02834         return internalRequestAllProperties();
02835     }
02836 
02837 public Q_SLOTS:
02868     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02869     {
02870         if (!invalidationReason().isEmpty()) {
02871             return QDBusPendingReply<>(QDBusMessage::createError(
02872                 invalidationReason(),
02873                 invalidationMessage()
02874             ));
02875         }
02876 
02877         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02878                 this->staticInterfaceName(), QLatin1String("AddMembers"));
02879         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02880         return this->connection().asyncCall(callMessage, timeout);
02881     }
02882 
02905     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
02906     {
02907         if (!invalidationReason().isEmpty()) {
02908             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02909                 invalidationReason(),
02910                 invalidationMessage()
02911             ));
02912         }
02913 
02914         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02915                 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
02916         return this->connection().asyncCall(callMessage, timeout);
02917     }
02918 
02933     inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
02934     {
02935         if (!invalidationReason().isEmpty()) {
02936             return QDBusPendingReply<uint>(QDBusMessage::createError(
02937                 invalidationReason(),
02938                 invalidationMessage()
02939             ));
02940         }
02941 
02942         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02943                 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
02944         return this->connection().asyncCall(callMessage, timeout);
02945     }
02946 
02972     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
02973     {
02974         if (!invalidationReason().isEmpty()) {
02975             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02976                 invalidationReason(),
02977                 invalidationMessage()
02978             ));
02979         }
02980 
02981         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02982                 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
02983         callMessage << QVariant::fromValue(handles);
02984         return this->connection().asyncCall(callMessage, timeout);
02985     }
02986 
02998     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
02999     {
03000         if (!invalidationReason().isEmpty()) {
03001             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
03002                 invalidationReason(),
03003                 invalidationMessage()
03004             ));
03005         }
03006 
03007         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03008                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
03009         return this->connection().asyncCall(callMessage, timeout);
03010     }
03011 
03030     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
03031     {
03032         if (!invalidationReason().isEmpty()) {
03033             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
03034                 invalidationReason(),
03035                 invalidationMessage()
03036             ));
03037         }
03038 
03039         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03040                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
03041         return this->connection().asyncCall(callMessage, timeout);
03042     }
03043 
03054     inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
03055     {
03056         if (!invalidationReason().isEmpty()) {
03057             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
03058                 invalidationReason(),
03059                 invalidationMessage()
03060             ));
03061         }
03062 
03063         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03064                 this->staticInterfaceName(), QLatin1String("GetMembers"));
03065         return this->connection().asyncCall(callMessage, timeout);
03066     }
03067 
03079     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
03080     {
03081         if (!invalidationReason().isEmpty()) {
03082             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
03083                 invalidationReason(),
03084                 invalidationMessage()
03085             ));
03086         }
03087 
03088         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03089                 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
03090         return this->connection().asyncCall(callMessage, timeout);
03091     }
03092 
03103     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
03104     {
03105         if (!invalidationReason().isEmpty()) {
03106             return QDBusPendingReply<uint>(QDBusMessage::createError(
03107                 invalidationReason(),
03108                 invalidationMessage()
03109             ));
03110         }
03111 
03112         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03113                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
03114         return this->connection().asyncCall(callMessage, timeout);
03115     }
03116 
03172     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
03173     {
03174         if (!invalidationReason().isEmpty()) {
03175             return QDBusPendingReply<>(QDBusMessage::createError(
03176                 invalidationReason(),
03177                 invalidationMessage()
03178             ));
03179         }
03180 
03181         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03182                 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
03183         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
03184         return this->connection().asyncCall(callMessage, timeout);
03185     }
03186 
03211     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
03212     {
03213         if (!invalidationReason().isEmpty()) {
03214             return QDBusPendingReply<>(QDBusMessage::createError(
03215                 invalidationReason(),
03216                 invalidationMessage()
03217             ));
03218         }
03219 
03220         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03221                 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
03222         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
03223         return this->connection().asyncCall(callMessage, timeout);
03224     }
03225 
03226 Q_SIGNALS:
03245     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
03246 
03275     void HandleOwnersChangedDetailed(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed, const Tp::HandleIdentifierMap& identifiers);
03276 
03286     void SelfHandleChanged(uint selfHandle);
03287 
03303     void SelfContactChanged(uint selfHandle, const QString& selfID);
03304 
03319     void GroupFlagsChanged(uint added, uint removed);
03320 
03374     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);
03375 
03484     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
03485 
03486 protected:
03487     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03488 };
03489 
03497 class TP_QT_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
03498 {
03499     Q_OBJECT
03500 
03501 public:
03508     static inline QLatin1String staticInterfaceName()
03509     {
03510         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
03511     }
03512 
03520     ChannelInterfaceHoldInterface(
03521         const QString& busName,
03522         const QString& objectPath,
03523         QObject* parent = 0
03524     );
03525 
03534     ChannelInterfaceHoldInterface(
03535         const QDBusConnection& connection,
03536         const QString& busName,
03537         const QString& objectPath,
03538         QObject* parent = 0
03539     );
03540 
03547     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
03548 
03556     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
03557 
03565     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03566 
03573     Tp::PendingVariantMap *requestAllProperties() const
03574     {
03575         return internalRequestAllProperties();
03576     }
03577 
03578 public Q_SLOTS:
03597     inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
03598     {
03599         if (!invalidationReason().isEmpty()) {
03600             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
03601                 invalidationReason(),
03602                 invalidationMessage()
03603             ));
03604         }
03605 
03606         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03607                 this->staticInterfaceName(), QLatin1String("GetHoldState"));
03608         return this->connection().asyncCall(callMessage, timeout);
03609     }
03610 
03674     inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
03675     {
03676         if (!invalidationReason().isEmpty()) {
03677             return QDBusPendingReply<>(QDBusMessage::createError(
03678                 invalidationReason(),
03679                 invalidationMessage()
03680             ));
03681         }
03682 
03683         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03684                 this->staticInterfaceName(), QLatin1String("RequestHold"));
03685         callMessage << QVariant::fromValue(hold);
03686         return this->connection().asyncCall(callMessage, timeout);
03687     }
03688 
03689 Q_SIGNALS:
03706     void HoldStateChanged(uint holdState, uint reason);
03707 
03708 protected:
03709     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03710 };
03711 
03719 class TP_QT_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
03720 {
03721     Q_OBJECT
03722 
03723 public:
03730     static inline QLatin1String staticInterfaceName()
03731     {
03732         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
03733     }
03734 
03742     ChannelInterfaceMediaSignallingInterface(
03743         const QString& busName,
03744         const QString& objectPath,
03745         QObject* parent = 0
03746     );
03747 
03756     ChannelInterfaceMediaSignallingInterface(
03757         const QDBusConnection& connection,
03758         const QString& busName,
03759         const QString& objectPath,
03760         QObject* parent = 0
03761     );
03762 
03769     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
03770 
03778     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
03779 
03787     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03788 
03795     Tp::PendingVariantMap *requestAllProperties() const
03796     {
03797         return internalRequestAllProperties();
03798     }
03799 
03800 public Q_SLOTS:
03812     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
03813     {
03814         if (!invalidationReason().isEmpty()) {
03815             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
03816                 invalidationReason(),
03817                 invalidationMessage()
03818             ));
03819         }
03820 
03821         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03822                 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
03823         return this->connection().asyncCall(callMessage, timeout);
03824     }
03825 
03826 Q_SIGNALS:
03842     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
03843 
03844 protected:
03845     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03846 };
03847 
03855 class TP_QT_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
03856 {
03857     Q_OBJECT
03858 
03859 public:
03866     static inline QLatin1String staticInterfaceName()
03867     {
03868         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
03869     }
03870 
03878     ChannelInterfaceMessagesInterface(
03879         const QString& busName,
03880         const QString& objectPath,
03881         QObject* parent = 0
03882     );
03883 
03892     ChannelInterfaceMessagesInterface(
03893         const QDBusConnection& connection,
03894         const QString& busName,
03895         const QString& objectPath,
03896         QObject* parent = 0
03897     );
03898 
03905     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
03906 
03914     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
03915 
03923     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03924 
03978     inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
03979     {
03980         return internalRequestProperty(QLatin1String("SupportedContentTypes"));
03981     }
03982 
03994     inline Tp::PendingVariant *requestPropertyMessageTypes() const
03995     {
03996         return internalRequestProperty(QLatin1String("MessageTypes"));
03997     }
03998 
04008     inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
04009     {
04010         return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
04011     }
04012 
04033     inline Tp::PendingVariant *requestPropertyPendingMessages() const
04034     {
04035         return internalRequestProperty(QLatin1String("PendingMessages"));
04036     }
04037 
04047     inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
04048     {
04049         return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
04050     }
04051 
04058     Tp::PendingVariantMap *requestAllProperties() const
04059     {
04060         return internalRequestAllProperties();
04061     }
04062 
04063 public Q_SLOTS:
04126     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
04127     {
04128         if (!invalidationReason().isEmpty()) {
04129             return QDBusPendingReply<QString>(QDBusMessage::createError(
04130                 invalidationReason(),
04131                 invalidationMessage()
04132             ));
04133         }
04134 
04135         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04136                 this->staticInterfaceName(), QLatin1String("SendMessage"));
04137         callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
04138         return this->connection().asyncCall(callMessage, timeout);
04139     }
04140 
04181     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
04182     {
04183         if (!invalidationReason().isEmpty()) {
04184             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
04185                 invalidationReason(),
04186                 invalidationMessage()
04187             ));
04188         }
04189 
04190         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04191                 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
04192         callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
04193         return this->connection().asyncCall(callMessage, timeout);
04194     }
04195 
04196 Q_SIGNALS:
04256     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
04257 
04271     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
04272 
04293     void MessageReceived(const Tp::MessagePartList& message);
04294 
04295 protected:
04296     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04297 };
04298 
04306 class TP_QT_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
04307 {
04308     Q_OBJECT
04309 
04310 public:
04317     static inline QLatin1String staticInterfaceName()
04318     {
04319         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
04320     }
04321 
04329     ChannelInterfacePasswordInterface(
04330         const QString& busName,
04331         const QString& objectPath,
04332         QObject* parent = 0
04333     );
04334 
04343     ChannelInterfacePasswordInterface(
04344         const QDBusConnection& connection,
04345         const QString& busName,
04346         const QString& objectPath,
04347         QObject* parent = 0
04348     );
04349 
04356     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
04357 
04365     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
04366 
04374     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04375 
04382     Tp::PendingVariantMap *requestAllProperties() const
04383     {
04384         return internalRequestAllProperties();
04385     }
04386 
04387 public Q_SLOTS:
04405     inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
04406     {
04407         if (!invalidationReason().isEmpty()) {
04408             return QDBusPendingReply<uint>(QDBusMessage::createError(
04409                 invalidationReason(),
04410                 invalidationMessage()
04411             ));
04412         }
04413 
04414         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04415                 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
04416         return this->connection().asyncCall(callMessage, timeout);
04417     }
04418 
04439     inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
04440     {
04441         if (!invalidationReason().isEmpty()) {
04442             return QDBusPendingReply<bool>(QDBusMessage::createError(
04443                 invalidationReason(),
04444                 invalidationMessage()
04445             ));
04446         }
04447 
04448         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04449                 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
04450         callMessage << QVariant::fromValue(password);
04451         return this->connection().asyncCall(callMessage, timeout);
04452     }
04453 
04454 Q_SIGNALS:
04469     void PasswordFlagsChanged(uint added, uint removed);
04470 
04471 protected:
04472     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04473 };
04474 
04482 class TP_QT_EXPORT ChannelInterfaceRoomConfigInterface : public Tp::AbstractInterface
04483 {
04484     Q_OBJECT
04485 
04486 public:
04493     static inline QLatin1String staticInterfaceName()
04494     {
04495         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.RoomConfig1");
04496     }
04497 
04505     ChannelInterfaceRoomConfigInterface(
04506         const QString& busName,
04507         const QString& objectPath,
04508         QObject* parent = 0
04509     );
04510 
04519     ChannelInterfaceRoomConfigInterface(
04520         const QDBusConnection& connection,
04521         const QString& busName,
04522         const QString& objectPath,
04523         QObject* parent = 0
04524     );
04525 
04532     ChannelInterfaceRoomConfigInterface(Tp::DBusProxy *proxy);
04533 
04541     explicit ChannelInterfaceRoomConfigInterface(const Tp::Client::ChannelInterface& mainInterface);
04542 
04550     ChannelInterfaceRoomConfigInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04551 
04562     inline Tp::PendingVariant *requestPropertyAnonymous() const
04563     {
04564         return internalRequestProperty(QLatin1String("Anonymous"));
04565     }
04566 
04576     inline Tp::PendingVariant *requestPropertyInviteOnly() const
04577     {
04578         return internalRequestProperty(QLatin1String("InviteOnly"));
04579     }
04580 
04590     inline Tp::PendingVariant *requestPropertyLimit() const
04591     {
04592         return internalRequestProperty(QLatin1String("Limit"));
04593     }
04594 
04604     inline Tp::PendingVariant *requestPropertyModerated() const
04605     {
04606         return internalRequestProperty(QLatin1String("Moderated"));
04607     }
04608 
04638     inline Tp::PendingVariant *requestPropertyTitle() const
04639     {
04640         return internalRequestProperty(QLatin1String("Title"));
04641     }
04642 
04653     inline Tp::PendingVariant *requestPropertyDescription() const
04654     {
04655         return internalRequestProperty(QLatin1String("Description"));
04656     }
04657 
04670     inline Tp::PendingVariant *requestPropertyPersistent() const
04671     {
04672         return internalRequestProperty(QLatin1String("Persistent"));
04673     }
04674 
04686     inline Tp::PendingVariant *requestPropertyPrivate() const
04687     {
04688         return internalRequestProperty(QLatin1String("Private"));
04689     }
04690 
04706     inline Tp::PendingVariant *requestPropertyPasswordProtected() const
04707     {
04708         return internalRequestProperty(QLatin1String("PasswordProtected"));
04709     }
04710 
04732     inline Tp::PendingVariant *requestPropertyPassword() const
04733     {
04734         return internalRequestProperty(QLatin1String("Password"));
04735     }
04736 
04759     inline Tp::PendingVariant *requestPropertyPasswordHint() const
04760     {
04761         return internalRequestProperty(QLatin1String("PasswordHint"));
04762     }
04763 
04778     inline Tp::PendingVariant *requestPropertyCanUpdateConfiguration() const
04779     {
04780         return internalRequestProperty(QLatin1String("CanUpdateConfiguration"));
04781     }
04782 
04805     inline Tp::PendingVariant *requestPropertyMutableProperties() const
04806     {
04807         return internalRequestProperty(QLatin1String("MutableProperties"));
04808     }
04809 
04834     inline Tp::PendingVariant *requestPropertyConfigurationRetrieved() const
04835     {
04836         return internalRequestProperty(QLatin1String("ConfigurationRetrieved"));
04837     }
04838 
04845     Tp::PendingVariantMap *requestAllProperties() const
04846     {
04847         return internalRequestAllProperties();
04848     }
04849 
04850 public Q_SLOTS:
04893     inline QDBusPendingReply<> UpdateConfiguration(const QVariantMap& properties, int timeout = -1)
04894     {
04895         if (!invalidationReason().isEmpty()) {
04896             return QDBusPendingReply<>(QDBusMessage::createError(
04897                 invalidationReason(),
04898                 invalidationMessage()
04899             ));
04900         }
04901 
04902         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04903                 this->staticInterfaceName(), QLatin1String("UpdateConfiguration"));
04904         callMessage << QVariant::fromValue(properties);
04905         return this->connection().asyncCall(callMessage, timeout);
04906     }
04907 
04908 protected:
04909     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04910 };
04911 
04919 class TP_QT_EXPORT ChannelInterfaceRoomInterface : public Tp::AbstractInterface
04920 {
04921     Q_OBJECT
04922 
04923 public:
04930     static inline QLatin1String staticInterfaceName()
04931     {
04932         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Room2");
04933     }
04934 
04942     ChannelInterfaceRoomInterface(
04943         const QString& busName,
04944         const QString& objectPath,
04945         QObject* parent = 0
04946     );
04947 
04956     ChannelInterfaceRoomInterface(
04957         const QDBusConnection& connection,
04958         const QString& busName,
04959         const QString& objectPath,
04960         QObject* parent = 0
04961     );
04962 
04969     ChannelInterfaceRoomInterface(Tp::DBusProxy *proxy);
04970 
04978     explicit ChannelInterfaceRoomInterface(const Tp::Client::ChannelInterface& mainInterface);
04979 
04987     ChannelInterfaceRoomInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04988 
05014     inline Tp::PendingVariant *requestPropertyRoomName() const
05015     {
05016         return internalRequestProperty(QLatin1String("RoomName"));
05017     }
05018 
05039     inline Tp::PendingVariant *requestPropertyServer() const
05040     {
05041         return internalRequestProperty(QLatin1String("Server"));
05042     }
05043 
05056     inline Tp::PendingVariant *requestPropertyCreator() const
05057     {
05058         return internalRequestProperty(QLatin1String("Creator"));
05059     }
05060 
05073     inline Tp::PendingVariant *requestPropertyCreatorHandle() const
05074     {
05075         return internalRequestProperty(QLatin1String("CreatorHandle"));
05076     }
05077 
05090     inline Tp::PendingVariant *requestPropertyCreationTimestamp() const
05091     {
05092         return internalRequestProperty(QLatin1String("CreationTimestamp"));
05093     }
05094 
05101     Tp::PendingVariantMap *requestAllProperties() const
05102     {
05103         return internalRequestAllProperties();
05104     }
05105 
05106 protected:
05107     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05108 };
05109 
05117 class TP_QT_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
05118 {
05119     Q_OBJECT
05120 
05121 public:
05128     static inline QLatin1String staticInterfaceName()
05129     {
05130         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
05131     }
05132 
05140     ChannelInterfaceSASLAuthenticationInterface(
05141         const QString& busName,
05142         const QString& objectPath,
05143         QObject* parent = 0
05144     );
05145 
05154     ChannelInterfaceSASLAuthenticationInterface(
05155         const QDBusConnection& connection,
05156         const QString& busName,
05157         const QString& objectPath,
05158         QObject* parent = 0
05159     );
05160 
05167     ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
05168 
05176     explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
05177 
05185     ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05186 
05209     inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
05210     {
05211         return internalRequestProperty(QLatin1String("AvailableMechanisms"));
05212     }
05213 
05235     inline Tp::PendingVariant *requestPropertyHasInitialData() const
05236     {
05237         return internalRequestProperty(QLatin1String("HasInitialData"));
05238     }
05239 
05260     inline Tp::PendingVariant *requestPropertyCanTryAgain() const
05261     {
05262         return internalRequestProperty(QLatin1String("CanTryAgain"));
05263     }
05264 
05278     inline Tp::PendingVariant *requestPropertySASLStatus() const
05279     {
05280         return internalRequestProperty(QLatin1String("SASLStatus"));
05281     }
05282 
05311     inline Tp::PendingVariant *requestPropertySASLError() const
05312     {
05313         return internalRequestProperty(QLatin1String("SASLError"));
05314     }
05315 
05337     inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
05338     {
05339         return internalRequestProperty(QLatin1String("SASLErrorDetails"));
05340     }
05341 
05406     inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
05407     {
05408         return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
05409     }
05410 
05472     inline Tp::PendingVariant *requestPropertyDefaultUsername() const
05473     {
05474         return internalRequestProperty(QLatin1String("DefaultUsername"));
05475     }
05476 
05504     inline Tp::PendingVariant *requestPropertyDefaultRealm() const
05505     {
05506         return internalRequestProperty(QLatin1String("DefaultRealm"));
05507     }
05508 
05530     inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
05531     {
05532         return internalRequestProperty(QLatin1String("MaySaveResponse"));
05533     }
05534 
05541     Tp::PendingVariantMap *requestAllProperties() const
05542     {
05543         return internalRequestAllProperties();
05544     }
05545 
05546 public Q_SLOTS:
05573     inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
05574     {
05575         if (!invalidationReason().isEmpty()) {
05576             return QDBusPendingReply<>(QDBusMessage::createError(
05577                 invalidationReason(),
05578                 invalidationMessage()
05579             ));
05580         }
05581 
05582         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05583                 this->staticInterfaceName(), QLatin1String("StartMechanism"));
05584         callMessage << QVariant::fromValue(mechanism);
05585         return this->connection().asyncCall(callMessage, timeout);
05586     }
05587 
05642     inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
05643     {
05644         if (!invalidationReason().isEmpty()) {
05645             return QDBusPendingReply<>(QDBusMessage::createError(
05646                 invalidationReason(),
05647                 invalidationMessage()
05648             ));
05649         }
05650 
05651         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05652                 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
05653         callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
05654         return this->connection().asyncCall(callMessage, timeout);
05655     }
05656 
05674     inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
05675     {
05676         if (!invalidationReason().isEmpty()) {
05677             return QDBusPendingReply<>(QDBusMessage::createError(
05678                 invalidationReason(),
05679                 invalidationMessage()
05680             ));
05681         }
05682 
05683         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05684                 this->staticInterfaceName(), QLatin1String("Respond"));
05685         callMessage << QVariant::fromValue(responseData);
05686         return this->connection().asyncCall(callMessage, timeout);
05687     }
05688 
05717     inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
05718     {
05719         if (!invalidationReason().isEmpty()) {
05720             return QDBusPendingReply<>(QDBusMessage::createError(
05721                 invalidationReason(),
05722                 invalidationMessage()
05723             ));
05724         }
05725 
05726         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05727                 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
05728         return this->connection().asyncCall(callMessage, timeout);
05729     }
05730 
05759     inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
05760     {
05761         if (!invalidationReason().isEmpty()) {
05762             return QDBusPendingReply<>(QDBusMessage::createError(
05763                 invalidationReason(),
05764                 invalidationMessage()
05765             ));
05766         }
05767 
05768         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05769                 this->staticInterfaceName(), QLatin1String("AbortSASL"));
05770         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
05771         return this->connection().asyncCall(callMessage, timeout);
05772     }
05773 
05774 Q_SIGNALS:
05792     void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
05793 
05813     void NewChallenge(const QByteArray& challengeData);
05814 
05815 protected:
05816     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05817 };
05818 
05826 class TP_QT_EXPORT ChannelInterfaceSMSInterface : public Tp::AbstractInterface
05827 {
05828     Q_OBJECT
05829 
05830 public:
05837     static inline QLatin1String staticInterfaceName()
05838     {
05839         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SMS");
05840     }
05841 
05849     ChannelInterfaceSMSInterface(
05850         const QString& busName,
05851         const QString& objectPath,
05852         QObject* parent = 0
05853     );
05854 
05863     ChannelInterfaceSMSInterface(
05864         const QDBusConnection& connection,
05865         const QString& busName,
05866         const QString& objectPath,
05867         QObject* parent = 0
05868     );
05869 
05876     ChannelInterfaceSMSInterface(Tp::DBusProxy *proxy);
05877 
05885     explicit ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface);
05886 
05894     ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05895 
05935     inline Tp::PendingVariant *requestPropertyFlash() const
05936     {
05937         return internalRequestProperty(QLatin1String("Flash"));
05938     }
05939 
06002     inline Tp::PendingVariant *requestPropertySMSChannel() const
06003     {
06004         return internalRequestProperty(QLatin1String("SMSChannel"));
06005     }
06006 
06013     Tp::PendingVariantMap *requestAllProperties() const
06014     {
06015         return internalRequestAllProperties();
06016     }
06017 
06018 public Q_SLOTS:
06083     inline QDBusPendingReply<uint, int, int> GetSMSLength(const Tp::MessagePartList& message, int timeout = -1)
06084     {
06085         if (!invalidationReason().isEmpty()) {
06086             return QDBusPendingReply<uint, int, int>(QDBusMessage::createError(
06087                 invalidationReason(),
06088                 invalidationMessage()
06089             ));
06090         }
06091 
06092         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06093                 this->staticInterfaceName(), QLatin1String("GetSMSLength"));
06094         callMessage << QVariant::fromValue(message);
06095         return this->connection().asyncCall(callMessage, timeout);
06096     }
06097 
06098 Q_SIGNALS:
06108     void SMSChannelChanged(bool SMSChannel);
06109 
06110 protected:
06111     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06112 };
06113 
06121 class TP_QT_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
06122 {
06123     Q_OBJECT
06124 
06125 public:
06132     static inline QLatin1String staticInterfaceName()
06133     {
06134         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
06135     }
06136 
06144     ChannelInterfaceSecurableInterface(
06145         const QString& busName,
06146         const QString& objectPath,
06147         QObject* parent = 0
06148     );
06149 
06158     ChannelInterfaceSecurableInterface(
06159         const QDBusConnection& connection,
06160         const QString& busName,
06161         const QString& objectPath,
06162         QObject* parent = 0
06163     );
06164 
06171     ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
06172 
06180     explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
06181 
06189     ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06190 
06212     inline Tp::PendingVariant *requestPropertyEncrypted() const
06213     {
06214         return internalRequestProperty(QLatin1String("Encrypted"));
06215     }
06216 
06233     inline Tp::PendingVariant *requestPropertyVerified() const
06234     {
06235         return internalRequestProperty(QLatin1String("Verified"));
06236     }
06237 
06244     Tp::PendingVariantMap *requestAllProperties() const
06245     {
06246         return internalRequestAllProperties();
06247     }
06248 
06249 protected:
06250     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06251 };
06252 
06260 class TP_QT_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
06261 {
06262     Q_OBJECT
06263 
06264 public:
06271     static inline QLatin1String staticInterfaceName()
06272     {
06273         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
06274     }
06275 
06283     ChannelInterfaceServicePointInterface(
06284         const QString& busName,
06285         const QString& objectPath,
06286         QObject* parent = 0
06287     );
06288 
06297     ChannelInterfaceServicePointInterface(
06298         const QDBusConnection& connection,
06299         const QString& busName,
06300         const QString& objectPath,
06301         QObject* parent = 0
06302     );
06303 
06310     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
06311 
06319     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
06320 
06328     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06329 
06349     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
06350     {
06351         return internalRequestProperty(QLatin1String("InitialServicePoint"));
06352     }
06353 
06366     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
06367     {
06368         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
06369     }
06370 
06377     Tp::PendingVariantMap *requestAllProperties() const
06378     {
06379         return internalRequestAllProperties();
06380     }
06381 
06382 Q_SIGNALS:
06399     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
06400 
06401 protected:
06402     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06403 };
06404 
06412 class TP_QT_EXPORT ChannelInterfaceSubjectInterface : public Tp::AbstractInterface
06413 {
06414     Q_OBJECT
06415 
06416 public:
06423     static inline QLatin1String staticInterfaceName()
06424     {
06425         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Subject2");
06426     }
06427 
06435     ChannelInterfaceSubjectInterface(
06436         const QString& busName,
06437         const QString& objectPath,
06438         QObject* parent = 0
06439     );
06440 
06449     ChannelInterfaceSubjectInterface(
06450         const QDBusConnection& connection,
06451         const QString& busName,
06452         const QString& objectPath,
06453         QObject* parent = 0
06454     );
06455 
06462     ChannelInterfaceSubjectInterface(Tp::DBusProxy *proxy);
06463 
06471     explicit ChannelInterfaceSubjectInterface(const Tp::Client::ChannelInterface& mainInterface);
06472 
06480     ChannelInterfaceSubjectInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06481 
06501     inline Tp::PendingVariant *requestPropertySubject() const
06502     {
06503         return internalRequestProperty(QLatin1String("Subject"));
06504     }
06505 
06522     inline Tp::PendingVariant *requestPropertyActor() const
06523     {
06524         return internalRequestProperty(QLatin1String("Actor"));
06525     }
06526 
06539     inline Tp::PendingVariant *requestPropertyActorHandle() const
06540     {
06541         return internalRequestProperty(QLatin1String("ActorHandle"));
06542     }
06543 
06560     inline Tp::PendingVariant *requestPropertyTimestamp() const
06561     {
06562         return internalRequestProperty(QLatin1String("Timestamp"));
06563     }
06564 
06589     inline Tp::PendingVariant *requestPropertyCanSet() const
06590     {
06591         return internalRequestProperty(QLatin1String("CanSet"));
06592     }
06593 
06600     Tp::PendingVariantMap *requestAllProperties() const
06601     {
06602         return internalRequestAllProperties();
06603     }
06604 
06605 public Q_SLOTS:
06629     inline QDBusPendingReply<> SetSubject(const QString& subject, int timeout = -1)
06630     {
06631         if (!invalidationReason().isEmpty()) {
06632             return QDBusPendingReply<>(QDBusMessage::createError(
06633                 invalidationReason(),
06634                 invalidationMessage()
06635             ));
06636         }
06637 
06638         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06639                 this->staticInterfaceName(), QLatin1String("SetSubject"));
06640         callMessage << QVariant::fromValue(subject);
06641         return this->connection().asyncCall(callMessage, timeout);
06642     }
06643 
06644 protected:
06645     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06646 };
06647 
06655 class TP_QT_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
06656 {
06657     Q_OBJECT
06658 
06659 public:
06666     static inline QLatin1String staticInterfaceName()
06667     {
06668         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
06669     }
06670 
06678     ChannelInterfaceTubeInterface(
06679         const QString& busName,
06680         const QString& objectPath,
06681         QObject* parent = 0
06682     );
06683 
06692     ChannelInterfaceTubeInterface(
06693         const QDBusConnection& connection,
06694         const QString& busName,
06695         const QString& objectPath,
06696         QObject* parent = 0
06697     );
06698 
06705     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
06706 
06714     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
06715 
06723     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06724 
06770     inline Tp::PendingVariant *requestPropertyParameters() const
06771     {
06772         return internalRequestProperty(QLatin1String("Parameters"));
06773     }
06774 
06790     inline Tp::PendingVariant *requestPropertyState() const
06791     {
06792         return internalRequestProperty(QLatin1String("State"));
06793     }
06794 
06801     Tp::PendingVariantMap *requestAllProperties() const
06802     {
06803         return internalRequestAllProperties();
06804     }
06805 
06806 Q_SIGNALS:
06817     void TubeChannelStateChanged(uint state);
06818 
06819 protected:
06820     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06821 };
06822 
06830 class TP_QT_EXPORT ChannelTypeCallInterface : public Tp::AbstractInterface
06831 {
06832     Q_OBJECT
06833 
06834 public:
06841     static inline QLatin1String staticInterfaceName()
06842     {
06843         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Call1");
06844     }
06845 
06853     ChannelTypeCallInterface(
06854         const QString& busName,
06855         const QString& objectPath,
06856         QObject* parent = 0
06857     );
06858 
06867     ChannelTypeCallInterface(
06868         const QDBusConnection& connection,
06869         const QString& busName,
06870         const QString& objectPath,
06871         QObject* parent = 0
06872     );
06873 
06880     ChannelTypeCallInterface(Tp::DBusProxy *proxy);
06881 
06889     explicit ChannelTypeCallInterface(const Tp::Client::ChannelInterface& mainInterface);
06890 
06898     ChannelTypeCallInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06899 
06915     inline Tp::PendingVariant *requestPropertyContents() const
06916     {
06917         return internalRequestProperty(QLatin1String("Contents"));
06918     }
06919 
06983     inline Tp::PendingVariant *requestPropertyCallStateDetails() const
06984     {
06985         return internalRequestProperty(QLatin1String("CallStateDetails"));
06986     }
06987 
07012     inline Tp::PendingVariant *requestPropertyCallState() const
07013     {
07014         return internalRequestProperty(QLatin1String("CallState"));
07015     }
07016 
07036     inline Tp::PendingVariant *requestPropertyCallFlags() const
07037     {
07038         return internalRequestProperty(QLatin1String("CallFlags"));
07039     }
07040 
07056     inline Tp::PendingVariant *requestPropertyCallStateReason() const
07057     {
07058         return internalRequestProperty(QLatin1String("CallStateReason"));
07059     }
07060 
07094     inline Tp::PendingVariant *requestPropertyHardwareStreaming() const
07095     {
07096         return internalRequestProperty(QLatin1String("HardwareStreaming"));
07097     }
07098 
07124     inline Tp::PendingVariant *requestPropertyCallMembers() const
07125     {
07126         return internalRequestProperty(QLatin1String("CallMembers"));
07127     }
07128 
07140     inline Tp::PendingVariant *requestPropertyMemberIdentifiers() const
07141     {
07142         return internalRequestProperty(QLatin1String("MemberIdentifiers"));
07143     }
07144 
07166     inline Tp::PendingVariant *requestPropertyInitialTransport() const
07167     {
07168         return internalRequestProperty(QLatin1String("InitialTransport"));
07169     }
07170 
07240     inline Tp::PendingVariant *requestPropertyInitialAudio() const
07241     {
07242         return internalRequestProperty(QLatin1String("InitialAudio"));
07243     }
07244 
07265     inline Tp::PendingVariant *requestPropertyInitialVideo() const
07266     {
07267         return internalRequestProperty(QLatin1String("InitialVideo"));
07268     }
07269 
07297     inline Tp::PendingVariant *requestPropertyInitialAudioName() const
07298     {
07299         return internalRequestProperty(QLatin1String("InitialAudioName"));
07300     }
07301 
07317     inline Tp::PendingVariant *requestPropertyInitialVideoName() const
07318     {
07319         return internalRequestProperty(QLatin1String("InitialVideoName"));
07320     }
07321 
07353     inline Tp::PendingVariant *requestPropertyMutableContents() const
07354     {
07355         return internalRequestProperty(QLatin1String("MutableContents"));
07356     }
07357 
07364     Tp::PendingVariantMap *requestAllProperties() const
07365     {
07366         return internalRequestAllProperties();
07367     }
07368 
07369 public Q_SLOTS:
07398     inline QDBusPendingReply<> SetRinging(int timeout = -1)
07399     {
07400         if (!invalidationReason().isEmpty()) {
07401             return QDBusPendingReply<>(QDBusMessage::createError(
07402                 invalidationReason(),
07403                 invalidationMessage()
07404             ));
07405         }
07406 
07407         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07408                 this->staticInterfaceName(), QLatin1String("SetRinging"));
07409         return this->connection().asyncCall(callMessage, timeout);
07410     }
07411 
07442     inline QDBusPendingReply<> SetQueued(int timeout = -1)
07443     {
07444         if (!invalidationReason().isEmpty()) {
07445             return QDBusPendingReply<>(QDBusMessage::createError(
07446                 invalidationReason(),
07447                 invalidationMessage()
07448             ));
07449         }
07450 
07451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07452                 this->staticInterfaceName(), QLatin1String("SetQueued"));
07453         return this->connection().asyncCall(callMessage, timeout);
07454     }
07455 
07490     inline QDBusPendingReply<> Accept(int timeout = -1)
07491     {
07492         if (!invalidationReason().isEmpty()) {
07493             return QDBusPendingReply<>(QDBusMessage::createError(
07494                 invalidationReason(),
07495                 invalidationMessage()
07496             ));
07497         }
07498 
07499         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07500                 this->staticInterfaceName(), QLatin1String("Accept"));
07501         return this->connection().asyncCall(callMessage, timeout);
07502     }
07503 
07529     inline QDBusPendingReply<> Hangup(uint reason, const QString& detailedHangupReason, const QString& message, int timeout = -1)
07530     {
07531         if (!invalidationReason().isEmpty()) {
07532             return QDBusPendingReply<>(QDBusMessage::createError(
07533                 invalidationReason(),
07534                 invalidationMessage()
07535             ));
07536         }
07537 
07538         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07539                 this->staticInterfaceName(), QLatin1String("Hangup"));
07540         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(detailedHangupReason) << QVariant::fromValue(message);
07541         return this->connection().asyncCall(callMessage, timeout);
07542     }
07543 
07582     inline QDBusPendingReply<QDBusObjectPath> AddContent(const QString& contentName, uint contentType, uint initialDirection, int timeout = -1)
07583     {
07584         if (!invalidationReason().isEmpty()) {
07585             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
07586                 invalidationReason(),
07587                 invalidationMessage()
07588             ));
07589         }
07590 
07591         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07592                 this->staticInterfaceName(), QLatin1String("AddContent"));
07593         callMessage << QVariant::fromValue(contentName) << QVariant::fromValue(contentType) << QVariant::fromValue(initialDirection);
07594         return this->connection().asyncCall(callMessage, timeout);
07595     }
07596 
07597 Q_SIGNALS:
07609     void ContentAdded(const QDBusObjectPath& content);
07610 
07626     void ContentRemoved(const QDBusObjectPath& content, const Tp::CallStateReason& reason);
07627 
07655     void CallStateChanged(uint callState, uint callFlags, const Tp::CallStateReason& callStateReason, const QVariantMap& callStateDetails);
07656 
07685     void CallMembersChanged(const Tp::CallMemberMap& flagsChanged, const Tp::HandleIdentifierMap& identifiers, const Tp::UIntList& removed, const Tp::CallStateReason& reason);
07686 
07687 protected:
07688     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07689 };
07690 
07698 class TP_QT_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
07699 {
07700     Q_OBJECT
07701 
07702 public:
07709     static inline QLatin1String staticInterfaceName()
07710     {
07711         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
07712     }
07713 
07721     ChannelTypeContactListInterface(
07722         const QString& busName,
07723         const QString& objectPath,
07724         QObject* parent = 0
07725     );
07726 
07735     ChannelTypeContactListInterface(
07736         const QDBusConnection& connection,
07737         const QString& busName,
07738         const QString& objectPath,
07739         QObject* parent = 0
07740     );
07741 
07748     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
07749 
07757     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
07758 
07766     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07767 
07774     Tp::PendingVariantMap *requestAllProperties() const
07775     {
07776         return internalRequestAllProperties();
07777     }
07778 
07779 protected:
07780     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07781 };
07782 
07790 class TP_QT_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
07791 {
07792     Q_OBJECT
07793 
07794 public:
07801     static inline QLatin1String staticInterfaceName()
07802     {
07803         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
07804     }
07805 
07813     ChannelTypeContactSearchInterface(
07814         const QString& busName,
07815         const QString& objectPath,
07816         QObject* parent = 0
07817     );
07818 
07827     ChannelTypeContactSearchInterface(
07828         const QDBusConnection& connection,
07829         const QString& busName,
07830         const QString& objectPath,
07831         QObject* parent = 0
07832     );
07833 
07840     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
07841 
07849     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
07850 
07858     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07859 
07870     inline Tp::PendingVariant *requestPropertySearchState() const
07871     {
07872         return internalRequestProperty(QLatin1String("SearchState"));
07873     }
07874 
07900     inline Tp::PendingVariant *requestPropertyLimit() const
07901     {
07902         return internalRequestProperty(QLatin1String("Limit"));
07903     }
07904 
07919     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
07920     {
07921         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
07922     }
07923 
07944     inline Tp::PendingVariant *requestPropertyServer() const
07945     {
07946         return internalRequestProperty(QLatin1String("Server"));
07947     }
07948 
07955     Tp::PendingVariantMap *requestAllProperties() const
07956     {
07957         return internalRequestAllProperties();
07958     }
07959 
07960 public Q_SLOTS:
07978     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
07979     {
07980         if (!invalidationReason().isEmpty()) {
07981             return QDBusPendingReply<>(QDBusMessage::createError(
07982                 invalidationReason(),
07983                 invalidationMessage()
07984             ));
07985         }
07986 
07987         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07988                 this->staticInterfaceName(), QLatin1String("Search"));
07989         callMessage << QVariant::fromValue(terms);
07990         return this->connection().asyncCall(callMessage, timeout);
07991     }
07992 
08007     inline QDBusPendingReply<> More(int timeout = -1)
08008     {
08009         if (!invalidationReason().isEmpty()) {
08010             return QDBusPendingReply<>(QDBusMessage::createError(
08011                 invalidationReason(),
08012                 invalidationMessage()
08013             ));
08014         }
08015 
08016         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08017                 this->staticInterfaceName(), QLatin1String("More"));
08018         return this->connection().asyncCall(callMessage, timeout);
08019     }
08020 
08053     inline QDBusPendingReply<> Stop(int timeout = -1)
08054     {
08055         if (!invalidationReason().isEmpty()) {
08056             return QDBusPendingReply<>(QDBusMessage::createError(
08057                 invalidationReason(),
08058                 invalidationMessage()
08059             ));
08060         }
08061 
08062         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08063                 this->staticInterfaceName(), QLatin1String("Stop"));
08064         return this->connection().asyncCall(callMessage, timeout);
08065     }
08066 
08067 Q_SIGNALS:
08117     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
08118 
08131     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
08132 
08133 protected:
08134     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08135 };
08136 
08144 class TP_QT_EXPORT ChannelTypeDBusTubeInterface : public Tp::AbstractInterface
08145 {
08146     Q_OBJECT
08147 
08148 public:
08155     static inline QLatin1String staticInterfaceName()
08156     {
08157         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.DBusTube");
08158     }
08159 
08167     ChannelTypeDBusTubeInterface(
08168         const QString& busName,
08169         const QString& objectPath,
08170         QObject* parent = 0
08171     );
08172 
08181     ChannelTypeDBusTubeInterface(
08182         const QDBusConnection& connection,
08183         const QString& busName,
08184         const QString& objectPath,
08185         QObject* parent = 0
08186     );
08187 
08194     ChannelTypeDBusTubeInterface(Tp::DBusProxy *proxy);
08195 
08203     explicit ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
08204 
08212     ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
08213 
08232     inline Tp::PendingVariant *requestPropertyServiceName() const
08233     {
08234         return internalRequestProperty(QLatin1String("ServiceName"));
08235     }
08236 
08249     inline Tp::PendingVariant *requestPropertyDBusNames() const
08250     {
08251         return internalRequestProperty(QLatin1String("DBusNames"));
08252     }
08253 
08281     inline Tp::PendingVariant *requestPropertySupportedAccessControls() const
08282     {
08283         return internalRequestProperty(QLatin1String("SupportedAccessControls"));
08284     }
08285 
08292     Tp::PendingVariantMap *requestAllProperties() const
08293     {
08294         return internalRequestAllProperties();
08295     }
08296 
08297 public Q_SLOTS:
08322     inline QDBusPendingReply<QString> Offer(const QVariantMap& parameters, uint accesscontrol, int timeout = -1)
08323     {
08324         if (!invalidationReason().isEmpty()) {
08325             return QDBusPendingReply<QString>(QDBusMessage::createError(
08326                 invalidationReason(),
08327                 invalidationMessage()
08328             ));
08329         }
08330 
08331         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08332                 this->staticInterfaceName(), QLatin1String("Offer"));
08333         callMessage << QVariant::fromValue(parameters) << QVariant::fromValue(accesscontrol);
08334         return this->connection().asyncCall(callMessage, timeout);
08335     }
08336 
08360     inline QDBusPendingReply<QString> Accept(uint accesscontrol, int timeout = -1)
08361     {
08362         if (!invalidationReason().isEmpty()) {
08363             return QDBusPendingReply<QString>(QDBusMessage::createError(
08364                 invalidationReason(),
08365                 invalidationMessage()
08366             ));
08367         }
08368 
08369         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08370                 this->staticInterfaceName(), QLatin1String("Accept"));
08371         callMessage << QVariant::fromValue(accesscontrol);
08372         return this->connection().asyncCall(callMessage, timeout);
08373     }
08374 
08375 Q_SIGNALS:
08391     void DBusNamesChanged(const Tp::DBusTubeParticipants& added, const Tp::UIntList& removed);
08392 
08393 protected:
08394     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08395 };
08396 
08404 class TP_QT_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
08405 {
08406     Q_OBJECT
08407 
08408 public:
08415     static inline QLatin1String staticInterfaceName()
08416     {
08417         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
08418     }
08419 
08427     ChannelTypeFileTransferInterface(
08428         const QString& busName,
08429         const QString& objectPath,
08430         QObject* parent = 0
08431     );
08432 
08441     ChannelTypeFileTransferInterface(
08442         const QDBusConnection& connection,
08443         const QString& busName,
08444         const QString& objectPath,
08445         QObject* parent = 0
08446     );
08447 
08454     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
08455 
08463     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
08464 
08472     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
08473 
08486     inline Tp::PendingVariant *requestPropertyState() const
08487     {
08488         return internalRequestProperty(QLatin1String("State"));
08489     }
08490 
08508     inline Tp::PendingVariant *requestPropertyContentType() const
08509     {
08510         return internalRequestProperty(QLatin1String("ContentType"));
08511     }
08512 
08534     inline Tp::PendingVariant *requestPropertyFilename() const
08535     {
08536         return internalRequestProperty(QLatin1String("Filename"));
08537     }
08538 
08562     inline Tp::PendingVariant *requestPropertySize() const
08563     {
08564         return internalRequestProperty(QLatin1String("Size"));
08565     }
08566 
08593     inline Tp::PendingVariant *requestPropertyContentHashType() const
08594     {
08595         return internalRequestProperty(QLatin1String("ContentHashType"));
08596     }
08597 
08618     inline Tp::PendingVariant *requestPropertyContentHash() const
08619     {
08620         return internalRequestProperty(QLatin1String("ContentHash"));
08621     }
08622 
08640     inline Tp::PendingVariant *requestPropertyDescription() const
08641     {
08642         return internalRequestProperty(QLatin1String("Description"));
08643     }
08644 
08661     inline Tp::PendingVariant *requestPropertyDate() const
08662     {
08663         return internalRequestProperty(QLatin1String("Date"));
08664     }
08665 
08694     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
08695     {
08696         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
08697     }
08698 
08712     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
08713     {
08714         return internalRequestProperty(QLatin1String("TransferredBytes"));
08715     }
08716 
08739     inline Tp::PendingVariant *requestPropertyInitialOffset() const
08740     {
08741         return internalRequestProperty(QLatin1String("InitialOffset"));
08742     }
08743 
08779     inline Tp::PendingVariant *requestPropertyURI() const
08780     {
08781         return internalRequestProperty(QLatin1String("URI"));
08782     }
08783 
08819     inline Tp::PendingOperation *setPropertyURI(QString newValue)
08820     {
08821         return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
08822     }
08823 
08856     inline Tp::PendingVariant *requestPropertyFileCollection() const
08857     {
08858         return internalRequestProperty(QLatin1String("FileCollection"));
08859     }
08860 
08867     Tp::PendingVariantMap *requestAllProperties() const
08868     {
08869         return internalRequestAllProperties();
08870     }
08871 
08872 public Q_SLOTS:
08917     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
08918     {
08919         if (!invalidationReason().isEmpty()) {
08920             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
08921                 invalidationReason(),
08922                 invalidationMessage()
08923             ));
08924         }
08925 
08926         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08927                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
08928         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
08929         return this->connection().asyncCall(callMessage, timeout);
08930     }
08931 
08965     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
08966     {
08967         if (!invalidationReason().isEmpty()) {
08968             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
08969                 invalidationReason(),
08970                 invalidationMessage()
08971             ));
08972         }
08973 
08974         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08975                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
08976         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
08977         return this->connection().asyncCall(callMessage, timeout);
08978     }
08979 
08980 Q_SIGNALS:
08998     void FileTransferStateChanged(uint state, uint reason);
08999 
09012     void TransferredBytesChanged(qulonglong count);
09013 
09025     void InitialOffsetDefined(qulonglong initialOffset);
09026 
09038     void URIDefined(const QString& URI);
09039 
09040 protected:
09041     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09042 };
09043 
09051 class TP_QT_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
09052 {
09053     Q_OBJECT
09054 
09055 public:
09062     static inline QLatin1String staticInterfaceName()
09063     {
09064         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
09065     }
09066 
09074     ChannelTypeRoomListInterface(
09075         const QString& busName,
09076         const QString& objectPath,
09077         QObject* parent = 0
09078     );
09079 
09088     ChannelTypeRoomListInterface(
09089         const QDBusConnection& connection,
09090         const QString& busName,
09091         const QString& objectPath,
09092         QObject* parent = 0
09093     );
09094 
09101     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
09102 
09110     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
09111 
09119     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09120 
09134     inline Tp::PendingVariant *requestPropertyServer() const
09135     {
09136         return internalRequestProperty(QLatin1String("Server"));
09137     }
09138 
09145     Tp::PendingVariantMap *requestAllProperties() const
09146     {
09147         return internalRequestAllProperties();
09148     }
09149 
09150 public Q_SLOTS:
09166     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
09167     {
09168         if (!invalidationReason().isEmpty()) {
09169             return QDBusPendingReply<bool>(QDBusMessage::createError(
09170                 invalidationReason(),
09171                 invalidationMessage()
09172             ));
09173         }
09174 
09175         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09176                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
09177         return this->connection().asyncCall(callMessage, timeout);
09178     }
09179 
09193     inline QDBusPendingReply<> ListRooms(int timeout = -1)
09194     {
09195         if (!invalidationReason().isEmpty()) {
09196             return QDBusPendingReply<>(QDBusMessage::createError(
09197                 invalidationReason(),
09198                 invalidationMessage()
09199             ));
09200         }
09201 
09202         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09203                 this->staticInterfaceName(), QLatin1String("ListRooms"));
09204         return this->connection().asyncCall(callMessage, timeout);
09205     }
09206 
09219     inline QDBusPendingReply<> StopListing(int timeout = -1)
09220     {
09221         if (!invalidationReason().isEmpty()) {
09222             return QDBusPendingReply<>(QDBusMessage::createError(
09223                 invalidationReason(),
09224                 invalidationMessage()
09225             ));
09226         }
09227 
09228         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09229                 this->staticInterfaceName(), QLatin1String("StopListing"));
09230         return this->connection().asyncCall(callMessage, timeout);
09231     }
09232 
09233 Q_SIGNALS:
09292     void GotRooms(const Tp::RoomInfoList& rooms);
09293 
09304     void ListingRooms(bool listing);
09305 
09306 protected:
09307     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09308 };
09309 
09317 class TP_QT_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
09318 {
09319     Q_OBJECT
09320 
09321 public:
09328     static inline QLatin1String staticInterfaceName()
09329     {
09330         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
09331     }
09332 
09340     ChannelTypeServerAuthenticationInterface(
09341         const QString& busName,
09342         const QString& objectPath,
09343         QObject* parent = 0
09344     );
09345 
09354     ChannelTypeServerAuthenticationInterface(
09355         const QDBusConnection& connection,
09356         const QString& busName,
09357         const QString& objectPath,
09358         QObject* parent = 0
09359     );
09360 
09367     ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
09368 
09376     explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
09377 
09385     ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09386 
09403     inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
09404     {
09405         return internalRequestProperty(QLatin1String("AuthenticationMethod"));
09406     }
09407 
09414     Tp::PendingVariantMap *requestAllProperties() const
09415     {
09416         return internalRequestAllProperties();
09417     }
09418 
09419 protected:
09420     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09421 };
09422 
09430 class TP_QT_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
09431 {
09432     Q_OBJECT
09433 
09434 public:
09441     static inline QLatin1String staticInterfaceName()
09442     {
09443         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
09444     }
09445 
09453     ChannelTypeServerTLSConnectionInterface(
09454         const QString& busName,
09455         const QString& objectPath,
09456         QObject* parent = 0
09457     );
09458 
09467     ChannelTypeServerTLSConnectionInterface(
09468         const QDBusConnection& connection,
09469         const QString& busName,
09470         const QString& objectPath,
09471         QObject* parent = 0
09472     );
09473 
09480     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
09481 
09489     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
09490 
09498     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09499 
09510     inline Tp::PendingVariant *requestPropertyServerCertificate() const
09511     {
09512         return internalRequestProperty(QLatin1String("ServerCertificate"));
09513     }
09514 
09528     inline Tp::PendingVariant *requestPropertyHostname() const
09529     {
09530         return internalRequestProperty(QLatin1String("Hostname"));
09531     }
09532 
09559     inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
09560     {
09561         return internalRequestProperty(QLatin1String("ReferenceIdentities"));
09562     }
09563 
09570     Tp::PendingVariantMap *requestAllProperties() const
09571     {
09572         return internalRequestAllProperties();
09573     }
09574 
09575 protected:
09576     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09577 };
09578 
09586 class TP_QT_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
09587 {
09588     Q_OBJECT
09589 
09590 public:
09597     static inline QLatin1String staticInterfaceName()
09598     {
09599         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
09600     }
09601 
09609     ChannelTypeStreamTubeInterface(
09610         const QString& busName,
09611         const QString& objectPath,
09612         QObject* parent = 0
09613     );
09614 
09623     ChannelTypeStreamTubeInterface(
09624         const QDBusConnection& connection,
09625         const QString& busName,
09626         const QString& objectPath,
09627         QObject* parent = 0
09628     );
09629 
09636     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
09637 
09645     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
09646 
09654     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09655 
09678     inline Tp::PendingVariant *requestPropertyService() const
09679     {
09680         return internalRequestProperty(QLatin1String("Service"));
09681     }
09682 
09717     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
09718     {
09719         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
09720     }
09721 
09728     Tp::PendingVariantMap *requestAllProperties() const
09729     {
09730         return internalRequestAllProperties();
09731     }
09732 
09733 public Q_SLOTS:
09764     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
09765     {
09766         if (!invalidationReason().isEmpty()) {
09767             return QDBusPendingReply<>(QDBusMessage::createError(
09768                 invalidationReason(),
09769                 invalidationMessage()
09770             ));
09771         }
09772 
09773         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09774                 this->staticInterfaceName(), QLatin1String("Offer"));
09775         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
09776         return this->connection().asyncCall(callMessage, timeout);
09777     }
09778 
09819     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
09820     {
09821         if (!invalidationReason().isEmpty()) {
09822             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
09823                 invalidationReason(),
09824                 invalidationMessage()
09825             ));
09826         }
09827 
09828         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09829                 this->staticInterfaceName(), QLatin1String("Accept"));
09830         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
09831         return this->connection().asyncCall(callMessage, timeout);
09832     }
09833 
09834 Q_SIGNALS:
09875     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
09876 
09892     void NewLocalConnection(uint connectionID);
09893 
09925     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
09926 
09927 protected:
09928     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09929 };
09930 
09938 class TP_QT_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
09939 {
09940     Q_OBJECT
09941 
09942 public:
09949     static inline QLatin1String staticInterfaceName()
09950     {
09951         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
09952     }
09953 
09961     ChannelTypeStreamedMediaInterface(
09962         const QString& busName,
09963         const QString& objectPath,
09964         QObject* parent = 0
09965     );
09966 
09975     ChannelTypeStreamedMediaInterface(
09976         const QDBusConnection& connection,
09977         const QString& busName,
09978         const QString& objectPath,
09979         QObject* parent = 0
09980     );
09981 
09988     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
09989 
09997     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
09998 
10006     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
10007 
10096     inline Tp::PendingVariant *requestPropertyInitialAudio() const
10097     {
10098         return internalRequestProperty(QLatin1String("InitialAudio"));
10099     }
10100 
10121     inline Tp::PendingVariant *requestPropertyInitialVideo() const
10122     {
10123         return internalRequestProperty(QLatin1String("InitialVideo"));
10124     }
10125 
10168     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
10169     {
10170         return internalRequestProperty(QLatin1String("ImmutableStreams"));
10171     }
10172 
10179     Tp::PendingVariantMap *requestAllProperties() const
10180     {
10181         return internalRequestAllProperties();
10182     }
10183 
10184 public Q_SLOTS:
10212     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
10213     {
10214         if (!invalidationReason().isEmpty()) {
10215             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
10216                 invalidationReason(),
10217                 invalidationMessage()
10218             ));
10219         }
10220 
10221         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10222                 this->staticInterfaceName(), QLatin1String("ListStreams"));
10223         return this->connection().asyncCall(callMessage, timeout);
10224     }
10225 
10252     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
10253     {
10254         if (!invalidationReason().isEmpty()) {
10255             return QDBusPendingReply<>(QDBusMessage::createError(
10256                 invalidationReason(),
10257                 invalidationMessage()
10258             ));
10259         }
10260 
10261         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10262                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
10263         callMessage << QVariant::fromValue(streams);
10264         return this->connection().asyncCall(callMessage, timeout);
10265     }
10266 
10303     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
10304     {
10305         if (!invalidationReason().isEmpty()) {
10306             return QDBusPendingReply<>(QDBusMessage::createError(
10307                 invalidationReason(),
10308                 invalidationMessage()
10309             ));
10310         }
10311 
10312         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10313                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
10314         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
10315         return this->connection().asyncCall(callMessage, timeout);
10316     }
10317 
10370     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
10371     {
10372         if (!invalidationReason().isEmpty()) {
10373             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
10374                 invalidationReason(),
10375                 invalidationMessage()
10376             ));
10377         }
10378 
10379         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10380                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
10381         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
10382         return this->connection().asyncCall(callMessage, timeout);
10383     }
10384 
10385 Q_SIGNALS:
10452     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
10453 
10485     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
10486 
10504     void StreamError(uint streamID, uint errorCode, const QString& message);
10505 
10515     void StreamRemoved(uint streamID);
10516 
10530     void StreamStateChanged(uint streamID, uint streamState);
10531 
10532 protected:
10533     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
10534 };
10535 
10543 class TP_QT_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
10544 {
10545     Q_OBJECT
10546 
10547 public:
10554     static inline QLatin1String staticInterfaceName()
10555     {
10556         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
10557     }
10558 
10566     ChannelTypeTextInterface(
10567         const QString& busName,
10568         const QString& objectPath,
10569         QObject* parent = 0
10570     );
10571 
10580     ChannelTypeTextInterface(
10581         const QDBusConnection& connection,
10582         const QString& busName,
10583         const QString& objectPath,
10584         QObject* parent = 0
10585     );
10586 
10593     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
10594 
10602     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
10603 
10611     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
10612 
10619     Tp::PendingVariantMap *requestAllProperties() const
10620     {
10621         return internalRequestAllProperties();
10622     }
10623 
10624 public Q_SLOTS:
10640     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
10641     {
10642         if (!invalidationReason().isEmpty()) {
10643             return QDBusPendingReply<>(QDBusMessage::createError(
10644                 invalidationReason(),
10645                 invalidationMessage()
10646             ));
10647         }
10648 
10649         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10650                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
10651         callMessage << QVariant::fromValue(IDs);
10652         return this->connection().asyncCall(callMessage, timeout);
10653     }
10654 
10670     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
10671     {
10672         if (!invalidationReason().isEmpty()) {
10673             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
10674                 invalidationReason(),
10675                 invalidationMessage()
10676             ));
10677         }
10678 
10679         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10680                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
10681         return this->connection().asyncCall(callMessage, timeout);
10682     }
10683 
10714     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
10715     {
10716         if (!invalidationReason().isEmpty()) {
10717             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
10718                 invalidationReason(),
10719                 invalidationMessage()
10720             ));
10721         }
10722 
10723         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10724                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
10725         callMessage << QVariant::fromValue(clear);
10726         return this->connection().asyncCall(callMessage, timeout);
10727     }
10728 
10761     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
10762     {
10763         if (!invalidationReason().isEmpty()) {
10764             return QDBusPendingReply<>(QDBusMessage::createError(
10765                 invalidationReason(),
10766                 invalidationMessage()
10767             ));
10768         }
10769 
10770         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10771                 this->staticInterfaceName(), QLatin1String("Send"));
10772         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
10773         return this->connection().asyncCall(callMessage, timeout);
10774     }
10775 
10776 Q_SIGNALS:
10784     void LostMessage();
10785 
10819     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
10820 
10849     void SendError(uint error, uint timestamp, uint type, const QString& text);
10850 
10874     void Sent(uint timestamp, uint type, const QString& text);
10875 
10876 protected:
10877     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
10878 };
10879 
10887 class TP_QT_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
10888 {
10889     Q_OBJECT
10890 
10891 public:
10898     static inline QLatin1String staticInterfaceName()
10899     {
10900         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
10901     }
10902 
10910     ChannelTypeTubesInterface(
10911         const QString& busName,
10912         const QString& objectPath,
10913         QObject* parent = 0
10914     );
10915 
10924     ChannelTypeTubesInterface(
10925         const QDBusConnection& connection,
10926         const QString& busName,
10927         const QString& objectPath,
10928         QObject* parent = 0
10929     );
10930 
10937     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
10938 
10946     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
10947 
10955     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
10956 
10963     Tp::PendingVariantMap *requestAllProperties() const
10964     {
10965         return internalRequestAllProperties();
10966     }
10967 
10968 public Q_SLOTS:
11005     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
11006     {
11007         if (!invalidationReason().isEmpty()) {
11008             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
11009                 invalidationReason(),
11010                 invalidationMessage()
11011             ));
11012         }
11013 
11014         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11015                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
11016         return this->connection().asyncCall(callMessage, timeout);
11017     }
11018 
11032     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
11033     {
11034         if (!invalidationReason().isEmpty()) {
11035             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
11036                 invalidationReason(),
11037                 invalidationMessage()
11038             ));
11039         }
11040 
11041         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11042                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
11043         return this->connection().asyncCall(callMessage, timeout);
11044     }
11045 
11061     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
11062     {
11063         if (!invalidationReason().isEmpty()) {
11064             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
11065                 invalidationReason(),
11066                 invalidationMessage()
11067             ));
11068         }
11069 
11070         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11071                 this->staticInterfaceName(), QLatin1String("ListTubes"));
11072         return this->connection().asyncCall(callMessage, timeout);
11073     }
11074 
11102     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
11103     {
11104         if (!invalidationReason().isEmpty()) {
11105             return QDBusPendingReply<uint>(QDBusMessage::createError(
11106                 invalidationReason(),
11107                 invalidationMessage()
11108             ));
11109         }
11110 
11111         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11112                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
11113         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
11114         return this->connection().asyncCall(callMessage, timeout);
11115     }
11116 
11176     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
11177     {
11178         if (!invalidationReason().isEmpty()) {
11179             return QDBusPendingReply<uint>(QDBusMessage::createError(
11180                 invalidationReason(),
11181                 invalidationMessage()
11182             ));
11183         }
11184 
11185         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11186                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
11187         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
11188         return this->connection().asyncCall(callMessage, timeout);
11189     }
11190 
11213     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
11214     {
11215         if (!invalidationReason().isEmpty()) {
11216             return QDBusPendingReply<QString>(QDBusMessage::createError(
11217                 invalidationReason(),
11218                 invalidationMessage()
11219             ));
11220         }
11221 
11222         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11223                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
11224         callMessage << QVariant::fromValue(ID);
11225         return this->connection().asyncCall(callMessage, timeout);
11226     }
11227 
11265     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
11266     {
11267         if (!invalidationReason().isEmpty()) {
11268             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
11269                 invalidationReason(),
11270                 invalidationMessage()
11271             ));
11272         }
11273 
11274         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11275                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
11276         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
11277         return this->connection().asyncCall(callMessage, timeout);
11278     }
11279 
11294     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
11295     {
11296         if (!invalidationReason().isEmpty()) {
11297             return QDBusPendingReply<>(QDBusMessage::createError(
11298                 invalidationReason(),
11299                 invalidationMessage()
11300             ));
11301         }
11302 
11303         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11304                 this->staticInterfaceName(), QLatin1String("CloseTube"));
11305         callMessage << QVariant::fromValue(ID);
11306         return this->connection().asyncCall(callMessage, timeout);
11307     }
11308 
11328     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
11329     {
11330         if (!invalidationReason().isEmpty()) {
11331             return QDBusPendingReply<QString>(QDBusMessage::createError(
11332                 invalidationReason(),
11333                 invalidationMessage()
11334             ));
11335         }
11336 
11337         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11338                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
11339         callMessage << QVariant::fromValue(ID);
11340         return this->connection().asyncCall(callMessage, timeout);
11341     }
11342 
11363     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
11364     {
11365         if (!invalidationReason().isEmpty()) {
11366             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
11367                 invalidationReason(),
11368                 invalidationMessage()
11369             ));
11370         }
11371 
11372         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11373                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
11374         callMessage << QVariant::fromValue(ID);
11375         return this->connection().asyncCall(callMessage, timeout);
11376     }
11377 
11403     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
11404     {
11405         if (!invalidationReason().isEmpty()) {
11406             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
11407                 invalidationReason(),
11408                 invalidationMessage()
11409             ));
11410         }
11411 
11412         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11413                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
11414         callMessage << QVariant::fromValue(ID);
11415         return this->connection().asyncCall(callMessage, timeout);
11416     }
11417 
11418 Q_SIGNALS:
11448     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
11449 
11463     void TubeStateChanged(uint ID, uint state);
11464 
11475     void TubeClosed(uint ID);
11476 
11495     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
11496 
11511     void StreamTubeNewConnection(uint ID, uint handle);
11512 
11513 protected:
11514     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
11515 };
11516 }
11517 }
11518 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
11519 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
11520 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
11521 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface*)
11522 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
11523 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
11524 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
11525 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDestroyableInterface*)
11526 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceFileTransferMetadataInterface*)
11527 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
11528 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
11529 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
11530 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
11531 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
11532 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceRoomConfigInterface*)
11533 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceRoomInterface*)
11534 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
11535 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSMSInterface*)
11536 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
11537 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
11538 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSubjectInterface*)
11539 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
11540 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeCallInterface*)
11541 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
11542 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
11543 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeDBusTubeInterface*)
11544 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
11545 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
11546 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
11547 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
11548 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
11549 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
11550 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
11551 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


Copyright © 2008-2011 Collabora Ltd. and Nokia Corporation
Telepathy-Qt 0.9.6.1