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 ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00927 {
00928     Q_OBJECT
00929 
00930 public:
00937     static inline QLatin1String staticInterfaceName()
00938     {
00939         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ChatState");
00940     }
00941 
00949     ChannelInterfaceChatStateInterface(
00950         const QString& busName,
00951         const QString& objectPath,
00952         QObject* parent = 0
00953     );
00954 
00963     ChannelInterfaceChatStateInterface(
00964         const QDBusConnection& connection,
00965         const QString& busName,
00966         const QString& objectPath,
00967         QObject* parent = 0
00968     );
00969 
00976     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00977 
00985     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00986 
00994     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00995 
01031     inline Tp::PendingVariant *requestPropertyChatStates() const
01032     {
01033         return internalRequestProperty(QLatin1String("ChatStates"));
01034     }
01035 
01042     Tp::PendingVariantMap *requestAllProperties() const
01043     {
01044         return internalRequestAllProperties();
01045     }
01046 
01047 public Q_SLOTS:
01063     inline QDBusPendingReply<> SetChatState(uint state, int timeout = -1)
01064     {
01065         if (!invalidationReason().isEmpty()) {
01066             return QDBusPendingReply<>(QDBusMessage::createError(
01067                 invalidationReason(),
01068                 invalidationMessage()
01069             ));
01070         }
01071 
01072         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01073                 this->staticInterfaceName(), QLatin1String("SetChatState"));
01074         callMessage << QVariant::fromValue(state);
01075         return this->connection().asyncCall(callMessage, timeout);
01076     }
01077 
01078 Q_SIGNALS:
01093     void ChatStateChanged(uint contact, uint state);
01094 
01095 protected:
01096     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01097 };
01098 
01106 class TP_QT_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
01107 {
01108     Q_OBJECT
01109 
01110 public:
01117     static inline QLatin1String staticInterfaceName()
01118     {
01119         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Conference");
01120     }
01121 
01129     ChannelInterfaceConferenceInterface(
01130         const QString& busName,
01131         const QString& objectPath,
01132         QObject* parent = 0
01133     );
01134 
01143     ChannelInterfaceConferenceInterface(
01144         const QDBusConnection& connection,
01145         const QString& busName,
01146         const QString& objectPath,
01147         QObject* parent = 0
01148     );
01149 
01156     ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
01157 
01165     explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
01166 
01174     ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01175 
01204     inline Tp::PendingVariant *requestPropertyChannels() const
01205     {
01206         return internalRequestProperty(QLatin1String("Channels"));
01207     }
01208 
01270     inline Tp::PendingVariant *requestPropertyInitialChannels() const
01271     {
01272         return internalRequestProperty(QLatin1String("InitialChannels"));
01273     }
01274 
01348     inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
01349     {
01350         return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
01351     }
01352 
01377     inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
01378     {
01379         return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
01380     }
01381 
01409     inline Tp::PendingVariant *requestPropertyInvitationMessage() const
01410     {
01411         return internalRequestProperty(QLatin1String("InvitationMessage"));
01412     }
01413 
01479     inline Tp::PendingVariant *requestPropertyOriginalChannels() const
01480     {
01481         return internalRequestProperty(QLatin1String("OriginalChannels"));
01482     }
01483 
01490     Tp::PendingVariantMap *requestAllProperties() const
01491     {
01492         return internalRequestAllProperties();
01493     }
01494 
01495 Q_SIGNALS:
01519     void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01520 
01545     void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01546 
01547 protected:
01548     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01549 };
01550 
01558 class TP_QT_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01559 {
01560     Q_OBJECT
01561 
01562 public:
01569     static inline QLatin1String staticInterfaceName()
01570     {
01571         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
01572     }
01573 
01581     ChannelInterfaceDTMFInterface(
01582         const QString& busName,
01583         const QString& objectPath,
01584         QObject* parent = 0
01585     );
01586 
01595     ChannelInterfaceDTMFInterface(
01596         const QDBusConnection& connection,
01597         const QString& busName,
01598         const QString& objectPath,
01599         QObject* parent = 0
01600     );
01601 
01608     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
01609 
01617     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
01618 
01626     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01627 
01639     inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
01640     {
01641         return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
01642     }
01643 
01656     inline Tp::PendingVariant *requestPropertyInitialTones() const
01657     {
01658         return internalRequestProperty(QLatin1String("InitialTones"));
01659     }
01660 
01678     inline Tp::PendingVariant *requestPropertyDeferredTones() const
01679     {
01680         return internalRequestProperty(QLatin1String("DeferredTones"));
01681     }
01682 
01689     Tp::PendingVariantMap *requestAllProperties() const
01690     {
01691         return internalRequestAllProperties();
01692     }
01693 
01694 public Q_SLOTS:
01725     inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
01726     {
01727         if (!invalidationReason().isEmpty()) {
01728             return QDBusPendingReply<>(QDBusMessage::createError(
01729                 invalidationReason(),
01730                 invalidationMessage()
01731             ));
01732         }
01733 
01734         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01735                 this->staticInterfaceName(), QLatin1String("StartTone"));
01736         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01737         return this->connection().asyncCall(callMessage, timeout);
01738     }
01739 
01762     inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
01763     {
01764         if (!invalidationReason().isEmpty()) {
01765             return QDBusPendingReply<>(QDBusMessage::createError(
01766                 invalidationReason(),
01767                 invalidationMessage()
01768             ));
01769         }
01770 
01771         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01772                 this->staticInterfaceName(), QLatin1String("StopTone"));
01773         callMessage << QVariant::fromValue(streamID);
01774         return this->connection().asyncCall(callMessage, timeout);
01775     }
01776 
01822     inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
01823     {
01824         if (!invalidationReason().isEmpty()) {
01825             return QDBusPendingReply<>(QDBusMessage::createError(
01826                 invalidationReason(),
01827                 invalidationMessage()
01828             ));
01829         }
01830 
01831         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01832                 this->staticInterfaceName(), QLatin1String("MultipleTones"));
01833         callMessage << QVariant::fromValue(tones);
01834         return this->connection().asyncCall(callMessage, timeout);
01835     }
01836 
01837 Q_SIGNALS:
01865     void TonesDeferred(const QString& tones);
01866 
01883     void SendingTones(const QString& tones);
01884 
01896     void StoppedTones(bool cancelled);
01897 
01898 protected:
01899     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01900 };
01901 
01909 class TP_QT_EXPORT ChannelInterfaceDestroyableInterface : public Tp::AbstractInterface
01910 {
01911     Q_OBJECT
01912 
01913 public:
01920     static inline QLatin1String staticInterfaceName()
01921     {
01922         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Destroyable");
01923     }
01924 
01932     ChannelInterfaceDestroyableInterface(
01933         const QString& busName,
01934         const QString& objectPath,
01935         QObject* parent = 0
01936     );
01937 
01946     ChannelInterfaceDestroyableInterface(
01947         const QDBusConnection& connection,
01948         const QString& busName,
01949         const QString& objectPath,
01950         QObject* parent = 0
01951     );
01952 
01959     ChannelInterfaceDestroyableInterface(Tp::DBusProxy *proxy);
01960 
01968     explicit ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface);
01969 
01977     ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01978 
01985     Tp::PendingVariantMap *requestAllProperties() const
01986     {
01987         return internalRequestAllProperties();
01988     }
01989 
01990 public Q_SLOTS:
02035     inline QDBusPendingReply<> Destroy(int timeout = -1)
02036     {
02037         if (!invalidationReason().isEmpty()) {
02038             return QDBusPendingReply<>(QDBusMessage::createError(
02039                 invalidationReason(),
02040                 invalidationMessage()
02041             ));
02042         }
02043 
02044         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02045                 this->staticInterfaceName(), QLatin1String("Destroy"));
02046         return this->connection().asyncCall(callMessage, timeout);
02047     }
02048 
02049 protected:
02050     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02051 };
02052 
02060 class TP_QT_EXPORT ChannelInterfaceFileTransferMetadataInterface : public Tp::AbstractInterface
02061 {
02062     Q_OBJECT
02063 
02064 public:
02071     static inline QLatin1String staticInterfaceName()
02072     {
02073         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.FileTransfer.Metadata");
02074     }
02075 
02083     ChannelInterfaceFileTransferMetadataInterface(
02084         const QString& busName,
02085         const QString& objectPath,
02086         QObject* parent = 0
02087     );
02088 
02097     ChannelInterfaceFileTransferMetadataInterface(
02098         const QDBusConnection& connection,
02099         const QString& busName,
02100         const QString& objectPath,
02101         QObject* parent = 0
02102     );
02103 
02110     ChannelInterfaceFileTransferMetadataInterface(Tp::DBusProxy *proxy);
02111 
02119     explicit ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface);
02120 
02128     ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02129 
02146     inline Tp::PendingVariant *requestPropertyServiceName() const
02147     {
02148         return internalRequestProperty(QLatin1String("ServiceName"));
02149     }
02150 
02167     inline Tp::PendingOperation *setPropertyServiceName(QString newValue)
02168     {
02169         return internalSetProperty(QLatin1String("ServiceName"), QVariant::fromValue(newValue));
02170     }
02171 
02185     inline Tp::PendingVariant *requestPropertyMetadata() const
02186     {
02187         return internalRequestProperty(QLatin1String("Metadata"));
02188     }
02189 
02203     inline Tp::PendingOperation *setPropertyMetadata(Tp::Metadata newValue)
02204     {
02205         return internalSetProperty(QLatin1String("Metadata"), QVariant::fromValue(newValue));
02206     }
02207 
02214     Tp::PendingVariantMap *requestAllProperties() const
02215     {
02216         return internalRequestAllProperties();
02217     }
02218 
02219 protected:
02220     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02221 };
02222 
02230 class TP_QT_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
02231 {
02232     Q_OBJECT
02233 
02234 public:
02241     static inline QLatin1String staticInterfaceName()
02242     {
02243         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
02244     }
02245 
02253     ChannelInterfaceGroupInterface(
02254         const QString& busName,
02255         const QString& objectPath,
02256         QObject* parent = 0
02257     );
02258 
02267     ChannelInterfaceGroupInterface(
02268         const QDBusConnection& connection,
02269         const QString& busName,
02270         const QString& objectPath,
02271         QObject* parent = 0
02272     );
02273 
02280     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
02281 
02289     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
02290 
02298     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02299 
02312     inline Tp::PendingVariant *requestPropertyGroupFlags() const
02313     {
02314         return internalRequestProperty(QLatin1String("GroupFlags"));
02315     }
02316 
02332     inline Tp::PendingVariant *requestPropertyHandleOwners() const
02333     {
02334         return internalRequestProperty(QLatin1String("HandleOwners"));
02335     }
02336 
02347     inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
02348     {
02349         return internalRequestProperty(QLatin1String("LocalPendingMembers"));
02350     }
02351 
02361     inline Tp::PendingVariant *requestPropertyMembers() const
02362     {
02363         return internalRequestProperty(QLatin1String("Members"));
02364     }
02365 
02376     inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
02377     {
02378         return internalRequestProperty(QLatin1String("RemotePendingMembers"));
02379     }
02380 
02395     inline Tp::PendingVariant *requestPropertySelfHandle() const
02396     {
02397         return internalRequestProperty(QLatin1String("SelfHandle"));
02398     }
02399 
02413     inline Tp::PendingVariant *requestPropertyMemberIdentifiers() const
02414     {
02415         return internalRequestProperty(QLatin1String("MemberIdentifiers"));
02416     }
02417 
02424     Tp::PendingVariantMap *requestAllProperties() const
02425     {
02426         return internalRequestAllProperties();
02427     }
02428 
02429 public Q_SLOTS:
02460     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02461     {
02462         if (!invalidationReason().isEmpty()) {
02463             return QDBusPendingReply<>(QDBusMessage::createError(
02464                 invalidationReason(),
02465                 invalidationMessage()
02466             ));
02467         }
02468 
02469         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02470                 this->staticInterfaceName(), QLatin1String("AddMembers"));
02471         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02472         return this->connection().asyncCall(callMessage, timeout);
02473     }
02474 
02497     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
02498     {
02499         if (!invalidationReason().isEmpty()) {
02500             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02501                 invalidationReason(),
02502                 invalidationMessage()
02503             ));
02504         }
02505 
02506         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02507                 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
02508         return this->connection().asyncCall(callMessage, timeout);
02509     }
02510 
02525     inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
02526     {
02527         if (!invalidationReason().isEmpty()) {
02528             return QDBusPendingReply<uint>(QDBusMessage::createError(
02529                 invalidationReason(),
02530                 invalidationMessage()
02531             ));
02532         }
02533 
02534         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02535                 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
02536         return this->connection().asyncCall(callMessage, timeout);
02537     }
02538 
02564     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
02565     {
02566         if (!invalidationReason().isEmpty()) {
02567             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02568                 invalidationReason(),
02569                 invalidationMessage()
02570             ));
02571         }
02572 
02573         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02574                 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
02575         callMessage << QVariant::fromValue(handles);
02576         return this->connection().asyncCall(callMessage, timeout);
02577     }
02578 
02590     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
02591     {
02592         if (!invalidationReason().isEmpty()) {
02593             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02594                 invalidationReason(),
02595                 invalidationMessage()
02596             ));
02597         }
02598 
02599         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02600                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
02601         return this->connection().asyncCall(callMessage, timeout);
02602     }
02603 
02622     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
02623     {
02624         if (!invalidationReason().isEmpty()) {
02625             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
02626                 invalidationReason(),
02627                 invalidationMessage()
02628             ));
02629         }
02630 
02631         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02632                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
02633         return this->connection().asyncCall(callMessage, timeout);
02634     }
02635 
02646     inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
02647     {
02648         if (!invalidationReason().isEmpty()) {
02649             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02650                 invalidationReason(),
02651                 invalidationMessage()
02652             ));
02653         }
02654 
02655         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02656                 this->staticInterfaceName(), QLatin1String("GetMembers"));
02657         return this->connection().asyncCall(callMessage, timeout);
02658     }
02659 
02671     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
02672     {
02673         if (!invalidationReason().isEmpty()) {
02674             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02675                 invalidationReason(),
02676                 invalidationMessage()
02677             ));
02678         }
02679 
02680         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02681                 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
02682         return this->connection().asyncCall(callMessage, timeout);
02683     }
02684 
02695     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
02696     {
02697         if (!invalidationReason().isEmpty()) {
02698             return QDBusPendingReply<uint>(QDBusMessage::createError(
02699                 invalidationReason(),
02700                 invalidationMessage()
02701             ));
02702         }
02703 
02704         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02705                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
02706         return this->connection().asyncCall(callMessage, timeout);
02707     }
02708 
02764     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02765     {
02766         if (!invalidationReason().isEmpty()) {
02767             return QDBusPendingReply<>(QDBusMessage::createError(
02768                 invalidationReason(),
02769                 invalidationMessage()
02770             ));
02771         }
02772 
02773         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02774                 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
02775         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02776         return this->connection().asyncCall(callMessage, timeout);
02777     }
02778 
02803     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
02804     {
02805         if (!invalidationReason().isEmpty()) {
02806             return QDBusPendingReply<>(QDBusMessage::createError(
02807                 invalidationReason(),
02808                 invalidationMessage()
02809             ));
02810         }
02811 
02812         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02813                 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
02814         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
02815         return this->connection().asyncCall(callMessage, timeout);
02816     }
02817 
02818 Q_SIGNALS:
02837     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
02838 
02867     void HandleOwnersChangedDetailed(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed, const Tp::HandleIdentifierMap& identifiers);
02868 
02878     void SelfHandleChanged(uint selfHandle);
02879 
02895     void SelfContactChanged(uint selfHandle, const QString& selfID);
02896 
02911     void GroupFlagsChanged(uint added, uint removed);
02912 
02966     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);
02967 
03076     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
03077 
03078 protected:
03079     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03080 };
03081 
03089 class TP_QT_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
03090 {
03091     Q_OBJECT
03092 
03093 public:
03100     static inline QLatin1String staticInterfaceName()
03101     {
03102         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
03103     }
03104 
03112     ChannelInterfaceHoldInterface(
03113         const QString& busName,
03114         const QString& objectPath,
03115         QObject* parent = 0
03116     );
03117 
03126     ChannelInterfaceHoldInterface(
03127         const QDBusConnection& connection,
03128         const QString& busName,
03129         const QString& objectPath,
03130         QObject* parent = 0
03131     );
03132 
03139     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
03140 
03148     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
03149 
03157     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03158 
03165     Tp::PendingVariantMap *requestAllProperties() const
03166     {
03167         return internalRequestAllProperties();
03168     }
03169 
03170 public Q_SLOTS:
03189     inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
03190     {
03191         if (!invalidationReason().isEmpty()) {
03192             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
03193                 invalidationReason(),
03194                 invalidationMessage()
03195             ));
03196         }
03197 
03198         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03199                 this->staticInterfaceName(), QLatin1String("GetHoldState"));
03200         return this->connection().asyncCall(callMessage, timeout);
03201     }
03202 
03266     inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
03267     {
03268         if (!invalidationReason().isEmpty()) {
03269             return QDBusPendingReply<>(QDBusMessage::createError(
03270                 invalidationReason(),
03271                 invalidationMessage()
03272             ));
03273         }
03274 
03275         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03276                 this->staticInterfaceName(), QLatin1String("RequestHold"));
03277         callMessage << QVariant::fromValue(hold);
03278         return this->connection().asyncCall(callMessage, timeout);
03279     }
03280 
03281 Q_SIGNALS:
03298     void HoldStateChanged(uint holdState, uint reason);
03299 
03300 protected:
03301     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03302 };
03303 
03311 class TP_QT_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
03312 {
03313     Q_OBJECT
03314 
03315 public:
03322     static inline QLatin1String staticInterfaceName()
03323     {
03324         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
03325     }
03326 
03334     ChannelInterfaceMediaSignallingInterface(
03335         const QString& busName,
03336         const QString& objectPath,
03337         QObject* parent = 0
03338     );
03339 
03348     ChannelInterfaceMediaSignallingInterface(
03349         const QDBusConnection& connection,
03350         const QString& busName,
03351         const QString& objectPath,
03352         QObject* parent = 0
03353     );
03354 
03361     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
03362 
03370     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
03371 
03379     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03380 
03387     Tp::PendingVariantMap *requestAllProperties() const
03388     {
03389         return internalRequestAllProperties();
03390     }
03391 
03392 public Q_SLOTS:
03404     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
03405     {
03406         if (!invalidationReason().isEmpty()) {
03407             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
03408                 invalidationReason(),
03409                 invalidationMessage()
03410             ));
03411         }
03412 
03413         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03414                 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
03415         return this->connection().asyncCall(callMessage, timeout);
03416     }
03417 
03418 Q_SIGNALS:
03434     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
03435 
03436 protected:
03437     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03438 };
03439 
03447 class TP_QT_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
03448 {
03449     Q_OBJECT
03450 
03451 public:
03458     static inline QLatin1String staticInterfaceName()
03459     {
03460         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
03461     }
03462 
03470     ChannelInterfaceMessagesInterface(
03471         const QString& busName,
03472         const QString& objectPath,
03473         QObject* parent = 0
03474     );
03475 
03484     ChannelInterfaceMessagesInterface(
03485         const QDBusConnection& connection,
03486         const QString& busName,
03487         const QString& objectPath,
03488         QObject* parent = 0
03489     );
03490 
03497     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
03498 
03506     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
03507 
03515     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03516 
03570     inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
03571     {
03572         return internalRequestProperty(QLatin1String("SupportedContentTypes"));
03573     }
03574 
03586     inline Tp::PendingVariant *requestPropertyMessageTypes() const
03587     {
03588         return internalRequestProperty(QLatin1String("MessageTypes"));
03589     }
03590 
03600     inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
03601     {
03602         return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
03603     }
03604 
03625     inline Tp::PendingVariant *requestPropertyPendingMessages() const
03626     {
03627         return internalRequestProperty(QLatin1String("PendingMessages"));
03628     }
03629 
03639     inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
03640     {
03641         return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
03642     }
03643 
03650     Tp::PendingVariantMap *requestAllProperties() const
03651     {
03652         return internalRequestAllProperties();
03653     }
03654 
03655 public Q_SLOTS:
03718     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
03719     {
03720         if (!invalidationReason().isEmpty()) {
03721             return QDBusPendingReply<QString>(QDBusMessage::createError(
03722                 invalidationReason(),
03723                 invalidationMessage()
03724             ));
03725         }
03726 
03727         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03728                 this->staticInterfaceName(), QLatin1String("SendMessage"));
03729         callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
03730         return this->connection().asyncCall(callMessage, timeout);
03731     }
03732 
03773     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
03774     {
03775         if (!invalidationReason().isEmpty()) {
03776             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
03777                 invalidationReason(),
03778                 invalidationMessage()
03779             ));
03780         }
03781 
03782         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03783                 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
03784         callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
03785         return this->connection().asyncCall(callMessage, timeout);
03786     }
03787 
03788 Q_SIGNALS:
03848     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
03849 
03863     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
03864 
03885     void MessageReceived(const Tp::MessagePartList& message);
03886 
03887 protected:
03888     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03889 };
03890 
03898 class TP_QT_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
03899 {
03900     Q_OBJECT
03901 
03902 public:
03909     static inline QLatin1String staticInterfaceName()
03910     {
03911         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
03912     }
03913 
03921     ChannelInterfacePasswordInterface(
03922         const QString& busName,
03923         const QString& objectPath,
03924         QObject* parent = 0
03925     );
03926 
03935     ChannelInterfacePasswordInterface(
03936         const QDBusConnection& connection,
03937         const QString& busName,
03938         const QString& objectPath,
03939         QObject* parent = 0
03940     );
03941 
03948     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
03949 
03957     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
03958 
03966     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03967 
03974     Tp::PendingVariantMap *requestAllProperties() const
03975     {
03976         return internalRequestAllProperties();
03977     }
03978 
03979 public Q_SLOTS:
03997     inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
03998     {
03999         if (!invalidationReason().isEmpty()) {
04000             return QDBusPendingReply<uint>(QDBusMessage::createError(
04001                 invalidationReason(),
04002                 invalidationMessage()
04003             ));
04004         }
04005 
04006         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04007                 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
04008         return this->connection().asyncCall(callMessage, timeout);
04009     }
04010 
04031     inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
04032     {
04033         if (!invalidationReason().isEmpty()) {
04034             return QDBusPendingReply<bool>(QDBusMessage::createError(
04035                 invalidationReason(),
04036                 invalidationMessage()
04037             ));
04038         }
04039 
04040         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04041                 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
04042         callMessage << QVariant::fromValue(password);
04043         return this->connection().asyncCall(callMessage, timeout);
04044     }
04045 
04046 Q_SIGNALS:
04061     void PasswordFlagsChanged(uint added, uint removed);
04062 
04063 protected:
04064     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04065 };
04066 
04074 class TP_QT_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
04075 {
04076     Q_OBJECT
04077 
04078 public:
04085     static inline QLatin1String staticInterfaceName()
04086     {
04087         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
04088     }
04089 
04097     ChannelInterfaceSASLAuthenticationInterface(
04098         const QString& busName,
04099         const QString& objectPath,
04100         QObject* parent = 0
04101     );
04102 
04111     ChannelInterfaceSASLAuthenticationInterface(
04112         const QDBusConnection& connection,
04113         const QString& busName,
04114         const QString& objectPath,
04115         QObject* parent = 0
04116     );
04117 
04124     ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
04125 
04133     explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
04134 
04142     ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04143 
04166     inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
04167     {
04168         return internalRequestProperty(QLatin1String("AvailableMechanisms"));
04169     }
04170 
04192     inline Tp::PendingVariant *requestPropertyHasInitialData() const
04193     {
04194         return internalRequestProperty(QLatin1String("HasInitialData"));
04195     }
04196 
04217     inline Tp::PendingVariant *requestPropertyCanTryAgain() const
04218     {
04219         return internalRequestProperty(QLatin1String("CanTryAgain"));
04220     }
04221 
04235     inline Tp::PendingVariant *requestPropertySASLStatus() const
04236     {
04237         return internalRequestProperty(QLatin1String("SASLStatus"));
04238     }
04239 
04268     inline Tp::PendingVariant *requestPropertySASLError() const
04269     {
04270         return internalRequestProperty(QLatin1String("SASLError"));
04271     }
04272 
04294     inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
04295     {
04296         return internalRequestProperty(QLatin1String("SASLErrorDetails"));
04297     }
04298 
04363     inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
04364     {
04365         return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
04366     }
04367 
04429     inline Tp::PendingVariant *requestPropertyDefaultUsername() const
04430     {
04431         return internalRequestProperty(QLatin1String("DefaultUsername"));
04432     }
04433 
04461     inline Tp::PendingVariant *requestPropertyDefaultRealm() const
04462     {
04463         return internalRequestProperty(QLatin1String("DefaultRealm"));
04464     }
04465 
04487     inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
04488     {
04489         return internalRequestProperty(QLatin1String("MaySaveResponse"));
04490     }
04491 
04498     Tp::PendingVariantMap *requestAllProperties() const
04499     {
04500         return internalRequestAllProperties();
04501     }
04502 
04503 public Q_SLOTS:
04530     inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
04531     {
04532         if (!invalidationReason().isEmpty()) {
04533             return QDBusPendingReply<>(QDBusMessage::createError(
04534                 invalidationReason(),
04535                 invalidationMessage()
04536             ));
04537         }
04538 
04539         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04540                 this->staticInterfaceName(), QLatin1String("StartMechanism"));
04541         callMessage << QVariant::fromValue(mechanism);
04542         return this->connection().asyncCall(callMessage, timeout);
04543     }
04544 
04599     inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
04600     {
04601         if (!invalidationReason().isEmpty()) {
04602             return QDBusPendingReply<>(QDBusMessage::createError(
04603                 invalidationReason(),
04604                 invalidationMessage()
04605             ));
04606         }
04607 
04608         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04609                 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
04610         callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
04611         return this->connection().asyncCall(callMessage, timeout);
04612     }
04613 
04631     inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
04632     {
04633         if (!invalidationReason().isEmpty()) {
04634             return QDBusPendingReply<>(QDBusMessage::createError(
04635                 invalidationReason(),
04636                 invalidationMessage()
04637             ));
04638         }
04639 
04640         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04641                 this->staticInterfaceName(), QLatin1String("Respond"));
04642         callMessage << QVariant::fromValue(responseData);
04643         return this->connection().asyncCall(callMessage, timeout);
04644     }
04645 
04674     inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
04675     {
04676         if (!invalidationReason().isEmpty()) {
04677             return QDBusPendingReply<>(QDBusMessage::createError(
04678                 invalidationReason(),
04679                 invalidationMessage()
04680             ));
04681         }
04682 
04683         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04684                 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
04685         return this->connection().asyncCall(callMessage, timeout);
04686     }
04687 
04716     inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
04717     {
04718         if (!invalidationReason().isEmpty()) {
04719             return QDBusPendingReply<>(QDBusMessage::createError(
04720                 invalidationReason(),
04721                 invalidationMessage()
04722             ));
04723         }
04724 
04725         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04726                 this->staticInterfaceName(), QLatin1String("AbortSASL"));
04727         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
04728         return this->connection().asyncCall(callMessage, timeout);
04729     }
04730 
04731 Q_SIGNALS:
04749     void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
04750 
04770     void NewChallenge(const QByteArray& challengeData);
04771 
04772 protected:
04773     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04774 };
04775 
04783 class TP_QT_EXPORT ChannelInterfaceSMSInterface : public Tp::AbstractInterface
04784 {
04785     Q_OBJECT
04786 
04787 public:
04794     static inline QLatin1String staticInterfaceName()
04795     {
04796         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SMS");
04797     }
04798 
04806     ChannelInterfaceSMSInterface(
04807         const QString& busName,
04808         const QString& objectPath,
04809         QObject* parent = 0
04810     );
04811 
04820     ChannelInterfaceSMSInterface(
04821         const QDBusConnection& connection,
04822         const QString& busName,
04823         const QString& objectPath,
04824         QObject* parent = 0
04825     );
04826 
04833     ChannelInterfaceSMSInterface(Tp::DBusProxy *proxy);
04834 
04842     explicit ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface);
04843 
04851     ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04852 
04892     inline Tp::PendingVariant *requestPropertyFlash() const
04893     {
04894         return internalRequestProperty(QLatin1String("Flash"));
04895     }
04896 
04959     inline Tp::PendingVariant *requestPropertySMSChannel() const
04960     {
04961         return internalRequestProperty(QLatin1String("SMSChannel"));
04962     }
04963 
04970     Tp::PendingVariantMap *requestAllProperties() const
04971     {
04972         return internalRequestAllProperties();
04973     }
04974 
04975 public Q_SLOTS:
05040     inline QDBusPendingReply<uint, int, int> GetSMSLength(const Tp::MessagePartList& message, int timeout = -1)
05041     {
05042         if (!invalidationReason().isEmpty()) {
05043             return QDBusPendingReply<uint, int, int>(QDBusMessage::createError(
05044                 invalidationReason(),
05045                 invalidationMessage()
05046             ));
05047         }
05048 
05049         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05050                 this->staticInterfaceName(), QLatin1String("GetSMSLength"));
05051         callMessage << QVariant::fromValue(message);
05052         return this->connection().asyncCall(callMessage, timeout);
05053     }
05054 
05055 Q_SIGNALS:
05065     void SMSChannelChanged(bool SMSChannel);
05066 
05067 protected:
05068     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05069 };
05070 
05078 class TP_QT_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
05079 {
05080     Q_OBJECT
05081 
05082 public:
05089     static inline QLatin1String staticInterfaceName()
05090     {
05091         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
05092     }
05093 
05101     ChannelInterfaceSecurableInterface(
05102         const QString& busName,
05103         const QString& objectPath,
05104         QObject* parent = 0
05105     );
05106 
05115     ChannelInterfaceSecurableInterface(
05116         const QDBusConnection& connection,
05117         const QString& busName,
05118         const QString& objectPath,
05119         QObject* parent = 0
05120     );
05121 
05128     ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
05129 
05137     explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
05138 
05146     ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05147 
05169     inline Tp::PendingVariant *requestPropertyEncrypted() const
05170     {
05171         return internalRequestProperty(QLatin1String("Encrypted"));
05172     }
05173 
05190     inline Tp::PendingVariant *requestPropertyVerified() const
05191     {
05192         return internalRequestProperty(QLatin1String("Verified"));
05193     }
05194 
05201     Tp::PendingVariantMap *requestAllProperties() const
05202     {
05203         return internalRequestAllProperties();
05204     }
05205 
05206 protected:
05207     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05208 };
05209 
05217 class TP_QT_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
05218 {
05219     Q_OBJECT
05220 
05221 public:
05228     static inline QLatin1String staticInterfaceName()
05229     {
05230         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
05231     }
05232 
05240     ChannelInterfaceServicePointInterface(
05241         const QString& busName,
05242         const QString& objectPath,
05243         QObject* parent = 0
05244     );
05245 
05254     ChannelInterfaceServicePointInterface(
05255         const QDBusConnection& connection,
05256         const QString& busName,
05257         const QString& objectPath,
05258         QObject* parent = 0
05259     );
05260 
05267     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
05268 
05276     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
05277 
05285     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05286 
05306     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
05307     {
05308         return internalRequestProperty(QLatin1String("InitialServicePoint"));
05309     }
05310 
05323     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
05324     {
05325         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
05326     }
05327 
05334     Tp::PendingVariantMap *requestAllProperties() const
05335     {
05336         return internalRequestAllProperties();
05337     }
05338 
05339 Q_SIGNALS:
05356     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
05357 
05358 protected:
05359     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05360 };
05361 
05369 class TP_QT_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
05370 {
05371     Q_OBJECT
05372 
05373 public:
05380     static inline QLatin1String staticInterfaceName()
05381     {
05382         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
05383     }
05384 
05392     ChannelInterfaceTubeInterface(
05393         const QString& busName,
05394         const QString& objectPath,
05395         QObject* parent = 0
05396     );
05397 
05406     ChannelInterfaceTubeInterface(
05407         const QDBusConnection& connection,
05408         const QString& busName,
05409         const QString& objectPath,
05410         QObject* parent = 0
05411     );
05412 
05419     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
05420 
05428     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
05429 
05437     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05438 
05484     inline Tp::PendingVariant *requestPropertyParameters() const
05485     {
05486         return internalRequestProperty(QLatin1String("Parameters"));
05487     }
05488 
05504     inline Tp::PendingVariant *requestPropertyState() const
05505     {
05506         return internalRequestProperty(QLatin1String("State"));
05507     }
05508 
05515     Tp::PendingVariantMap *requestAllProperties() const
05516     {
05517         return internalRequestAllProperties();
05518     }
05519 
05520 Q_SIGNALS:
05531     void TubeChannelStateChanged(uint state);
05532 
05533 protected:
05534     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05535 };
05536 
05544 class TP_QT_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
05545 {
05546     Q_OBJECT
05547 
05548 public:
05555     static inline QLatin1String staticInterfaceName()
05556     {
05557         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
05558     }
05559 
05567     ChannelTypeContactListInterface(
05568         const QString& busName,
05569         const QString& objectPath,
05570         QObject* parent = 0
05571     );
05572 
05581     ChannelTypeContactListInterface(
05582         const QDBusConnection& connection,
05583         const QString& busName,
05584         const QString& objectPath,
05585         QObject* parent = 0
05586     );
05587 
05594     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
05595 
05603     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
05604 
05612     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05613 
05620     Tp::PendingVariantMap *requestAllProperties() const
05621     {
05622         return internalRequestAllProperties();
05623     }
05624 
05625 protected:
05626     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05627 };
05628 
05636 class TP_QT_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
05637 {
05638     Q_OBJECT
05639 
05640 public:
05647     static inline QLatin1String staticInterfaceName()
05648     {
05649         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
05650     }
05651 
05659     ChannelTypeContactSearchInterface(
05660         const QString& busName,
05661         const QString& objectPath,
05662         QObject* parent = 0
05663     );
05664 
05673     ChannelTypeContactSearchInterface(
05674         const QDBusConnection& connection,
05675         const QString& busName,
05676         const QString& objectPath,
05677         QObject* parent = 0
05678     );
05679 
05686     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
05687 
05695     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
05696 
05704     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05705 
05716     inline Tp::PendingVariant *requestPropertySearchState() const
05717     {
05718         return internalRequestProperty(QLatin1String("SearchState"));
05719     }
05720 
05746     inline Tp::PendingVariant *requestPropertyLimit() const
05747     {
05748         return internalRequestProperty(QLatin1String("Limit"));
05749     }
05750 
05765     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
05766     {
05767         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
05768     }
05769 
05790     inline Tp::PendingVariant *requestPropertyServer() const
05791     {
05792         return internalRequestProperty(QLatin1String("Server"));
05793     }
05794 
05801     Tp::PendingVariantMap *requestAllProperties() const
05802     {
05803         return internalRequestAllProperties();
05804     }
05805 
05806 public Q_SLOTS:
05824     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
05825     {
05826         if (!invalidationReason().isEmpty()) {
05827             return QDBusPendingReply<>(QDBusMessage::createError(
05828                 invalidationReason(),
05829                 invalidationMessage()
05830             ));
05831         }
05832 
05833         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05834                 this->staticInterfaceName(), QLatin1String("Search"));
05835         callMessage << QVariant::fromValue(terms);
05836         return this->connection().asyncCall(callMessage, timeout);
05837     }
05838 
05853     inline QDBusPendingReply<> More(int timeout = -1)
05854     {
05855         if (!invalidationReason().isEmpty()) {
05856             return QDBusPendingReply<>(QDBusMessage::createError(
05857                 invalidationReason(),
05858                 invalidationMessage()
05859             ));
05860         }
05861 
05862         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05863                 this->staticInterfaceName(), QLatin1String("More"));
05864         return this->connection().asyncCall(callMessage, timeout);
05865     }
05866 
05899     inline QDBusPendingReply<> Stop(int timeout = -1)
05900     {
05901         if (!invalidationReason().isEmpty()) {
05902             return QDBusPendingReply<>(QDBusMessage::createError(
05903                 invalidationReason(),
05904                 invalidationMessage()
05905             ));
05906         }
05907 
05908         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05909                 this->staticInterfaceName(), QLatin1String("Stop"));
05910         return this->connection().asyncCall(callMessage, timeout);
05911     }
05912 
05913 Q_SIGNALS:
05963     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
05964 
05977     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
05978 
05979 protected:
05980     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05981 };
05982 
05990 class TP_QT_EXPORT ChannelTypeDBusTubeInterface : public Tp::AbstractInterface
05991 {
05992     Q_OBJECT
05993 
05994 public:
06001     static inline QLatin1String staticInterfaceName()
06002     {
06003         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.DBusTube");
06004     }
06005 
06013     ChannelTypeDBusTubeInterface(
06014         const QString& busName,
06015         const QString& objectPath,
06016         QObject* parent = 0
06017     );
06018 
06027     ChannelTypeDBusTubeInterface(
06028         const QDBusConnection& connection,
06029         const QString& busName,
06030         const QString& objectPath,
06031         QObject* parent = 0
06032     );
06033 
06040     ChannelTypeDBusTubeInterface(Tp::DBusProxy *proxy);
06041 
06049     explicit ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
06050 
06058     ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06059 
06078     inline Tp::PendingVariant *requestPropertyServiceName() const
06079     {
06080         return internalRequestProperty(QLatin1String("ServiceName"));
06081     }
06082 
06095     inline Tp::PendingVariant *requestPropertyDBusNames() const
06096     {
06097         return internalRequestProperty(QLatin1String("DBusNames"));
06098     }
06099 
06127     inline Tp::PendingVariant *requestPropertySupportedAccessControls() const
06128     {
06129         return internalRequestProperty(QLatin1String("SupportedAccessControls"));
06130     }
06131 
06138     Tp::PendingVariantMap *requestAllProperties() const
06139     {
06140         return internalRequestAllProperties();
06141     }
06142 
06143 public Q_SLOTS:
06168     inline QDBusPendingReply<QString> Offer(const QVariantMap& parameters, uint accesscontrol, int timeout = -1)
06169     {
06170         if (!invalidationReason().isEmpty()) {
06171             return QDBusPendingReply<QString>(QDBusMessage::createError(
06172                 invalidationReason(),
06173                 invalidationMessage()
06174             ));
06175         }
06176 
06177         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06178                 this->staticInterfaceName(), QLatin1String("Offer"));
06179         callMessage << QVariant::fromValue(parameters) << QVariant::fromValue(accesscontrol);
06180         return this->connection().asyncCall(callMessage, timeout);
06181     }
06182 
06206     inline QDBusPendingReply<QString> Accept(uint accesscontrol, int timeout = -1)
06207     {
06208         if (!invalidationReason().isEmpty()) {
06209             return QDBusPendingReply<QString>(QDBusMessage::createError(
06210                 invalidationReason(),
06211                 invalidationMessage()
06212             ));
06213         }
06214 
06215         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06216                 this->staticInterfaceName(), QLatin1String("Accept"));
06217         callMessage << QVariant::fromValue(accesscontrol);
06218         return this->connection().asyncCall(callMessage, timeout);
06219     }
06220 
06221 Q_SIGNALS:
06237     void DBusNamesChanged(const Tp::DBusTubeParticipants& added, const Tp::UIntList& removed);
06238 
06239 protected:
06240     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06241 };
06242 
06250 class TP_QT_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
06251 {
06252     Q_OBJECT
06253 
06254 public:
06261     static inline QLatin1String staticInterfaceName()
06262     {
06263         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
06264     }
06265 
06273     ChannelTypeFileTransferInterface(
06274         const QString& busName,
06275         const QString& objectPath,
06276         QObject* parent = 0
06277     );
06278 
06287     ChannelTypeFileTransferInterface(
06288         const QDBusConnection& connection,
06289         const QString& busName,
06290         const QString& objectPath,
06291         QObject* parent = 0
06292     );
06293 
06300     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
06301 
06309     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
06310 
06318     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06319 
06332     inline Tp::PendingVariant *requestPropertyState() const
06333     {
06334         return internalRequestProperty(QLatin1String("State"));
06335     }
06336 
06354     inline Tp::PendingVariant *requestPropertyContentType() const
06355     {
06356         return internalRequestProperty(QLatin1String("ContentType"));
06357     }
06358 
06380     inline Tp::PendingVariant *requestPropertyFilename() const
06381     {
06382         return internalRequestProperty(QLatin1String("Filename"));
06383     }
06384 
06408     inline Tp::PendingVariant *requestPropertySize() const
06409     {
06410         return internalRequestProperty(QLatin1String("Size"));
06411     }
06412 
06439     inline Tp::PendingVariant *requestPropertyContentHashType() const
06440     {
06441         return internalRequestProperty(QLatin1String("ContentHashType"));
06442     }
06443 
06464     inline Tp::PendingVariant *requestPropertyContentHash() const
06465     {
06466         return internalRequestProperty(QLatin1String("ContentHash"));
06467     }
06468 
06486     inline Tp::PendingVariant *requestPropertyDescription() const
06487     {
06488         return internalRequestProperty(QLatin1String("Description"));
06489     }
06490 
06507     inline Tp::PendingVariant *requestPropertyDate() const
06508     {
06509         return internalRequestProperty(QLatin1String("Date"));
06510     }
06511 
06540     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
06541     {
06542         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
06543     }
06544 
06558     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
06559     {
06560         return internalRequestProperty(QLatin1String("TransferredBytes"));
06561     }
06562 
06585     inline Tp::PendingVariant *requestPropertyInitialOffset() const
06586     {
06587         return internalRequestProperty(QLatin1String("InitialOffset"));
06588     }
06589 
06625     inline Tp::PendingVariant *requestPropertyURI() const
06626     {
06627         return internalRequestProperty(QLatin1String("URI"));
06628     }
06629 
06665     inline Tp::PendingOperation *setPropertyURI(QString newValue)
06666     {
06667         return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
06668     }
06669 
06676     Tp::PendingVariantMap *requestAllProperties() const
06677     {
06678         return internalRequestAllProperties();
06679     }
06680 
06681 public Q_SLOTS:
06726     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
06727     {
06728         if (!invalidationReason().isEmpty()) {
06729             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06730                 invalidationReason(),
06731                 invalidationMessage()
06732             ));
06733         }
06734 
06735         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06736                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
06737         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
06738         return this->connection().asyncCall(callMessage, timeout);
06739     }
06740 
06774     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
06775     {
06776         if (!invalidationReason().isEmpty()) {
06777             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06778                 invalidationReason(),
06779                 invalidationMessage()
06780             ));
06781         }
06782 
06783         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06784                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
06785         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
06786         return this->connection().asyncCall(callMessage, timeout);
06787     }
06788 
06789 Q_SIGNALS:
06807     void FileTransferStateChanged(uint state, uint reason);
06808 
06821     void TransferredBytesChanged(qulonglong count);
06822 
06834     void InitialOffsetDefined(qulonglong initialOffset);
06835 
06847     void URIDefined(const QString& URI);
06848 
06849 protected:
06850     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06851 };
06852 
06860 class TP_QT_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
06861 {
06862     Q_OBJECT
06863 
06864 public:
06871     static inline QLatin1String staticInterfaceName()
06872     {
06873         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
06874     }
06875 
06883     ChannelTypeRoomListInterface(
06884         const QString& busName,
06885         const QString& objectPath,
06886         QObject* parent = 0
06887     );
06888 
06897     ChannelTypeRoomListInterface(
06898         const QDBusConnection& connection,
06899         const QString& busName,
06900         const QString& objectPath,
06901         QObject* parent = 0
06902     );
06903 
06910     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
06911 
06919     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
06920 
06928     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06929 
06943     inline Tp::PendingVariant *requestPropertyServer() const
06944     {
06945         return internalRequestProperty(QLatin1String("Server"));
06946     }
06947 
06954     Tp::PendingVariantMap *requestAllProperties() const
06955     {
06956         return internalRequestAllProperties();
06957     }
06958 
06959 public Q_SLOTS:
06975     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
06976     {
06977         if (!invalidationReason().isEmpty()) {
06978             return QDBusPendingReply<bool>(QDBusMessage::createError(
06979                 invalidationReason(),
06980                 invalidationMessage()
06981             ));
06982         }
06983 
06984         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06985                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
06986         return this->connection().asyncCall(callMessage, timeout);
06987     }
06988 
07002     inline QDBusPendingReply<> ListRooms(int timeout = -1)
07003     {
07004         if (!invalidationReason().isEmpty()) {
07005             return QDBusPendingReply<>(QDBusMessage::createError(
07006                 invalidationReason(),
07007                 invalidationMessage()
07008             ));
07009         }
07010 
07011         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07012                 this->staticInterfaceName(), QLatin1String("ListRooms"));
07013         return this->connection().asyncCall(callMessage, timeout);
07014     }
07015 
07028     inline QDBusPendingReply<> StopListing(int timeout = -1)
07029     {
07030         if (!invalidationReason().isEmpty()) {
07031             return QDBusPendingReply<>(QDBusMessage::createError(
07032                 invalidationReason(),
07033                 invalidationMessage()
07034             ));
07035         }
07036 
07037         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07038                 this->staticInterfaceName(), QLatin1String("StopListing"));
07039         return this->connection().asyncCall(callMessage, timeout);
07040     }
07041 
07042 Q_SIGNALS:
07100     void GotRooms(const Tp::RoomInfoList& rooms);
07101 
07112     void ListingRooms(bool listing);
07113 
07114 protected:
07115     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07116 };
07117 
07125 class TP_QT_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
07126 {
07127     Q_OBJECT
07128 
07129 public:
07136     static inline QLatin1String staticInterfaceName()
07137     {
07138         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
07139     }
07140 
07148     ChannelTypeServerAuthenticationInterface(
07149         const QString& busName,
07150         const QString& objectPath,
07151         QObject* parent = 0
07152     );
07153 
07162     ChannelTypeServerAuthenticationInterface(
07163         const QDBusConnection& connection,
07164         const QString& busName,
07165         const QString& objectPath,
07166         QObject* parent = 0
07167     );
07168 
07175     ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
07176 
07184     explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
07185 
07193     ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07194 
07211     inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
07212     {
07213         return internalRequestProperty(QLatin1String("AuthenticationMethod"));
07214     }
07215 
07222     Tp::PendingVariantMap *requestAllProperties() const
07223     {
07224         return internalRequestAllProperties();
07225     }
07226 
07227 protected:
07228     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07229 };
07230 
07238 class TP_QT_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
07239 {
07240     Q_OBJECT
07241 
07242 public:
07249     static inline QLatin1String staticInterfaceName()
07250     {
07251         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
07252     }
07253 
07261     ChannelTypeServerTLSConnectionInterface(
07262         const QString& busName,
07263         const QString& objectPath,
07264         QObject* parent = 0
07265     );
07266 
07275     ChannelTypeServerTLSConnectionInterface(
07276         const QDBusConnection& connection,
07277         const QString& busName,
07278         const QString& objectPath,
07279         QObject* parent = 0
07280     );
07281 
07288     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
07289 
07297     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
07298 
07306     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07307 
07318     inline Tp::PendingVariant *requestPropertyServerCertificate() const
07319     {
07320         return internalRequestProperty(QLatin1String("ServerCertificate"));
07321     }
07322 
07336     inline Tp::PendingVariant *requestPropertyHostname() const
07337     {
07338         return internalRequestProperty(QLatin1String("Hostname"));
07339     }
07340 
07367     inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
07368     {
07369         return internalRequestProperty(QLatin1String("ReferenceIdentities"));
07370     }
07371 
07378     Tp::PendingVariantMap *requestAllProperties() const
07379     {
07380         return internalRequestAllProperties();
07381     }
07382 
07383 protected:
07384     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07385 };
07386 
07394 class TP_QT_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
07395 {
07396     Q_OBJECT
07397 
07398 public:
07405     static inline QLatin1String staticInterfaceName()
07406     {
07407         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
07408     }
07409 
07417     ChannelTypeStreamTubeInterface(
07418         const QString& busName,
07419         const QString& objectPath,
07420         QObject* parent = 0
07421     );
07422 
07431     ChannelTypeStreamTubeInterface(
07432         const QDBusConnection& connection,
07433         const QString& busName,
07434         const QString& objectPath,
07435         QObject* parent = 0
07436     );
07437 
07444     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
07445 
07453     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
07454 
07462     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07463 
07486     inline Tp::PendingVariant *requestPropertyService() const
07487     {
07488         return internalRequestProperty(QLatin1String("Service"));
07489     }
07490 
07525     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
07526     {
07527         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
07528     }
07529 
07536     Tp::PendingVariantMap *requestAllProperties() const
07537     {
07538         return internalRequestAllProperties();
07539     }
07540 
07541 public Q_SLOTS:
07572     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
07573     {
07574         if (!invalidationReason().isEmpty()) {
07575             return QDBusPendingReply<>(QDBusMessage::createError(
07576                 invalidationReason(),
07577                 invalidationMessage()
07578             ));
07579         }
07580 
07581         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07582                 this->staticInterfaceName(), QLatin1String("Offer"));
07583         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
07584         return this->connection().asyncCall(callMessage, timeout);
07585     }
07586 
07627     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
07628     {
07629         if (!invalidationReason().isEmpty()) {
07630             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
07631                 invalidationReason(),
07632                 invalidationMessage()
07633             ));
07634         }
07635 
07636         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07637                 this->staticInterfaceName(), QLatin1String("Accept"));
07638         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
07639         return this->connection().asyncCall(callMessage, timeout);
07640     }
07641 
07642 Q_SIGNALS:
07683     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
07684 
07700     void NewLocalConnection(uint connectionID);
07701 
07733     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
07734 
07735 protected:
07736     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07737 };
07738 
07746 class TP_QT_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
07747 {
07748     Q_OBJECT
07749 
07750 public:
07757     static inline QLatin1String staticInterfaceName()
07758     {
07759         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
07760     }
07761 
07769     ChannelTypeStreamedMediaInterface(
07770         const QString& busName,
07771         const QString& objectPath,
07772         QObject* parent = 0
07773     );
07774 
07783     ChannelTypeStreamedMediaInterface(
07784         const QDBusConnection& connection,
07785         const QString& busName,
07786         const QString& objectPath,
07787         QObject* parent = 0
07788     );
07789 
07796     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
07797 
07805     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
07806 
07814     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07815 
07904     inline Tp::PendingVariant *requestPropertyInitialAudio() const
07905     {
07906         return internalRequestProperty(QLatin1String("InitialAudio"));
07907     }
07908 
07929     inline Tp::PendingVariant *requestPropertyInitialVideo() const
07930     {
07931         return internalRequestProperty(QLatin1String("InitialVideo"));
07932     }
07933 
07976     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
07977     {
07978         return internalRequestProperty(QLatin1String("ImmutableStreams"));
07979     }
07980 
07987     Tp::PendingVariantMap *requestAllProperties() const
07988     {
07989         return internalRequestAllProperties();
07990     }
07991 
07992 public Q_SLOTS:
08020     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
08021     {
08022         if (!invalidationReason().isEmpty()) {
08023             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
08024                 invalidationReason(),
08025                 invalidationMessage()
08026             ));
08027         }
08028 
08029         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08030                 this->staticInterfaceName(), QLatin1String("ListStreams"));
08031         return this->connection().asyncCall(callMessage, timeout);
08032     }
08033 
08060     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
08061     {
08062         if (!invalidationReason().isEmpty()) {
08063             return QDBusPendingReply<>(QDBusMessage::createError(
08064                 invalidationReason(),
08065                 invalidationMessage()
08066             ));
08067         }
08068 
08069         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08070                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
08071         callMessage << QVariant::fromValue(streams);
08072         return this->connection().asyncCall(callMessage, timeout);
08073     }
08074 
08111     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
08112     {
08113         if (!invalidationReason().isEmpty()) {
08114             return QDBusPendingReply<>(QDBusMessage::createError(
08115                 invalidationReason(),
08116                 invalidationMessage()
08117             ));
08118         }
08119 
08120         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08121                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
08122         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
08123         return this->connection().asyncCall(callMessage, timeout);
08124     }
08125 
08178     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
08179     {
08180         if (!invalidationReason().isEmpty()) {
08181             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
08182                 invalidationReason(),
08183                 invalidationMessage()
08184             ));
08185         }
08186 
08187         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08188                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
08189         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
08190         return this->connection().asyncCall(callMessage, timeout);
08191     }
08192 
08193 Q_SIGNALS:
08260     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
08261 
08293     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
08294 
08312     void StreamError(uint streamID, uint errorCode, const QString& message);
08313 
08323     void StreamRemoved(uint streamID);
08324 
08338     void StreamStateChanged(uint streamID, uint streamState);
08339 
08340 protected:
08341     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08342 };
08343 
08351 class TP_QT_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
08352 {
08353     Q_OBJECT
08354 
08355 public:
08362     static inline QLatin1String staticInterfaceName()
08363     {
08364         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
08365     }
08366 
08374     ChannelTypeTextInterface(
08375         const QString& busName,
08376         const QString& objectPath,
08377         QObject* parent = 0
08378     );
08379 
08388     ChannelTypeTextInterface(
08389         const QDBusConnection& connection,
08390         const QString& busName,
08391         const QString& objectPath,
08392         QObject* parent = 0
08393     );
08394 
08401     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
08402 
08410     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
08411 
08419     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
08420 
08427     Tp::PendingVariantMap *requestAllProperties() const
08428     {
08429         return internalRequestAllProperties();
08430     }
08431 
08432 public Q_SLOTS:
08448     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
08449     {
08450         if (!invalidationReason().isEmpty()) {
08451             return QDBusPendingReply<>(QDBusMessage::createError(
08452                 invalidationReason(),
08453                 invalidationMessage()
08454             ));
08455         }
08456 
08457         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08458                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
08459         callMessage << QVariant::fromValue(IDs);
08460         return this->connection().asyncCall(callMessage, timeout);
08461     }
08462 
08478     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
08479     {
08480         if (!invalidationReason().isEmpty()) {
08481             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
08482                 invalidationReason(),
08483                 invalidationMessage()
08484             ));
08485         }
08486 
08487         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08488                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
08489         return this->connection().asyncCall(callMessage, timeout);
08490     }
08491 
08522     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
08523     {
08524         if (!invalidationReason().isEmpty()) {
08525             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
08526                 invalidationReason(),
08527                 invalidationMessage()
08528             ));
08529         }
08530 
08531         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08532                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
08533         callMessage << QVariant::fromValue(clear);
08534         return this->connection().asyncCall(callMessage, timeout);
08535     }
08536 
08569     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
08570     {
08571         if (!invalidationReason().isEmpty()) {
08572             return QDBusPendingReply<>(QDBusMessage::createError(
08573                 invalidationReason(),
08574                 invalidationMessage()
08575             ));
08576         }
08577 
08578         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08579                 this->staticInterfaceName(), QLatin1String("Send"));
08580         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
08581         return this->connection().asyncCall(callMessage, timeout);
08582     }
08583 
08584 Q_SIGNALS:
08592     void LostMessage();
08593 
08627     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
08628 
08657     void SendError(uint error, uint timestamp, uint type, const QString& text);
08658 
08682     void Sent(uint timestamp, uint type, const QString& text);
08683 
08684 protected:
08685     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08686 };
08687 
08695 class TP_QT_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
08696 {
08697     Q_OBJECT
08698 
08699 public:
08706     static inline QLatin1String staticInterfaceName()
08707     {
08708         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
08709     }
08710 
08718     ChannelTypeTubesInterface(
08719         const QString& busName,
08720         const QString& objectPath,
08721         QObject* parent = 0
08722     );
08723 
08732     ChannelTypeTubesInterface(
08733         const QDBusConnection& connection,
08734         const QString& busName,
08735         const QString& objectPath,
08736         QObject* parent = 0
08737     );
08738 
08745     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
08746 
08754     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
08755 
08763     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
08764 
08771     Tp::PendingVariantMap *requestAllProperties() const
08772     {
08773         return internalRequestAllProperties();
08774     }
08775 
08776 public Q_SLOTS:
08813     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
08814     {
08815         if (!invalidationReason().isEmpty()) {
08816             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
08817                 invalidationReason(),
08818                 invalidationMessage()
08819             ));
08820         }
08821 
08822         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08823                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
08824         return this->connection().asyncCall(callMessage, timeout);
08825     }
08826 
08840     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
08841     {
08842         if (!invalidationReason().isEmpty()) {
08843             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
08844                 invalidationReason(),
08845                 invalidationMessage()
08846             ));
08847         }
08848 
08849         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08850                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
08851         return this->connection().asyncCall(callMessage, timeout);
08852     }
08853 
08869     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
08870     {
08871         if (!invalidationReason().isEmpty()) {
08872             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
08873                 invalidationReason(),
08874                 invalidationMessage()
08875             ));
08876         }
08877 
08878         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08879                 this->staticInterfaceName(), QLatin1String("ListTubes"));
08880         return this->connection().asyncCall(callMessage, timeout);
08881     }
08882 
08910     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
08911     {
08912         if (!invalidationReason().isEmpty()) {
08913             return QDBusPendingReply<uint>(QDBusMessage::createError(
08914                 invalidationReason(),
08915                 invalidationMessage()
08916             ));
08917         }
08918 
08919         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08920                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
08921         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
08922         return this->connection().asyncCall(callMessage, timeout);
08923     }
08924 
08984     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
08985     {
08986         if (!invalidationReason().isEmpty()) {
08987             return QDBusPendingReply<uint>(QDBusMessage::createError(
08988                 invalidationReason(),
08989                 invalidationMessage()
08990             ));
08991         }
08992 
08993         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08994                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
08995         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
08996         return this->connection().asyncCall(callMessage, timeout);
08997     }
08998 
09021     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
09022     {
09023         if (!invalidationReason().isEmpty()) {
09024             return QDBusPendingReply<QString>(QDBusMessage::createError(
09025                 invalidationReason(),
09026                 invalidationMessage()
09027             ));
09028         }
09029 
09030         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09031                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
09032         callMessage << QVariant::fromValue(ID);
09033         return this->connection().asyncCall(callMessage, timeout);
09034     }
09035 
09073     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
09074     {
09075         if (!invalidationReason().isEmpty()) {
09076             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
09077                 invalidationReason(),
09078                 invalidationMessage()
09079             ));
09080         }
09081 
09082         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09083                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
09084         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
09085         return this->connection().asyncCall(callMessage, timeout);
09086     }
09087 
09102     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
09103     {
09104         if (!invalidationReason().isEmpty()) {
09105             return QDBusPendingReply<>(QDBusMessage::createError(
09106                 invalidationReason(),
09107                 invalidationMessage()
09108             ));
09109         }
09110 
09111         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09112                 this->staticInterfaceName(), QLatin1String("CloseTube"));
09113         callMessage << QVariant::fromValue(ID);
09114         return this->connection().asyncCall(callMessage, timeout);
09115     }
09116 
09136     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
09137     {
09138         if (!invalidationReason().isEmpty()) {
09139             return QDBusPendingReply<QString>(QDBusMessage::createError(
09140                 invalidationReason(),
09141                 invalidationMessage()
09142             ));
09143         }
09144 
09145         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09146                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
09147         callMessage << QVariant::fromValue(ID);
09148         return this->connection().asyncCall(callMessage, timeout);
09149     }
09150 
09171     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
09172     {
09173         if (!invalidationReason().isEmpty()) {
09174             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
09175                 invalidationReason(),
09176                 invalidationMessage()
09177             ));
09178         }
09179 
09180         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09181                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
09182         callMessage << QVariant::fromValue(ID);
09183         return this->connection().asyncCall(callMessage, timeout);
09184     }
09185 
09211     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
09212     {
09213         if (!invalidationReason().isEmpty()) {
09214             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
09215                 invalidationReason(),
09216                 invalidationMessage()
09217             ));
09218         }
09219 
09220         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09221                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
09222         callMessage << QVariant::fromValue(ID);
09223         return this->connection().asyncCall(callMessage, timeout);
09224     }
09225 
09226 Q_SIGNALS:
09256     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
09257 
09271     void TubeStateChanged(uint ID, uint state);
09272 
09283     void TubeClosed(uint ID);
09284 
09303     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
09304 
09319     void StreamTubeNewConnection(uint ID, uint handle);
09320 
09321 protected:
09322     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09323 };
09324 }
09325 }
09326 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
09327 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
09328 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
09329 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
09330 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
09331 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
09332 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDestroyableInterface*)
09333 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceFileTransferMetadataInterface*)
09334 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
09335 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
09336 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
09337 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
09338 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
09339 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
09340 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSMSInterface*)
09341 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
09342 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
09343 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
09344 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
09345 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
09346 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeDBusTubeInterface*)
09347 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
09348 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
09349 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
09350 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
09351 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
09352 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
09353 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
09354 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


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