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

cli-channel.h

    00001 /*
    00002  * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
    00003  *
    00004  * This file can be distributed under the same terms as the specification from
    00005  * which it was generated.
    00006  */
    00007
    00008 #ifndef IN_TELEPATHY_QT4_HEADER
    00009 #error IN_TELEPATHY_QT4_HEADER
    00010 #endif
    00011
    00012 #include <TelepathyQt4/Types>
    00013
    00014 #include <QtGlobal>
    00015
    00016 #include <QString>
    00017 #include <QObject>
    00018 #include <QVariant>
    00019
    00020 #include <QDBusPendingReply>
    00021
    00022 #include <TelepathyQt4/AbstractInterface>
    00023 #include <TelepathyQt4/DBusProxy>
    00024 #include <TelepathyQt4/Global>
    00025
    00026 namespace Tp
    00027 {
    00028 class PendingVariant;
    00029 class PendingOperation;
    00030 }
    00031
    00032 namespace Tp
    00033 {
    00034 namespace Client
    00035 {
    00036
    00044 class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
    00045 {
    00046     Q_OBJECT
    00047
    00048 public:
    00055     static inline QLatin1String staticInterfaceName()
    00056     {
    00057         return QLatin1String("org.freedesktop.Telepathy.Channel");
    00058     }
    00059
    00067     ChannelInterface(
    00068         const QString& busName,
    00069         const QString& objectPath,
    00070         QObject* parent = 0
    00071     );
    00072
    00081     ChannelInterface(
    00082         const QDBusConnection& connection,
    00083         const QString& busName,
    00084         const QString& objectPath,
    00085         QObject* parent = 0
    00086     );
    00087
    00094     ChannelInterface(Tp::DBusProxy *proxy);
    00095
    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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
    02061 {
    02062     Q_OBJECT
    02063
    02064 public:
    02071     static inline QLatin1String staticInterfaceName()
    02072     {
    02073         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
    02074     }
    02075
    02083     ChannelInterfaceGroupInterface(
    02084         const QString& busName,
    02085         const QString& objectPath,
    02086         QObject* parent = 0
    02087     );
    02088
    02097     ChannelInterfaceGroupInterface(
    02098         const QDBusConnection& connection,
    02099         const QString& busName,
    02100         const QString& objectPath,
    02101         QObject* parent = 0
    02102     );
    02103
    02110     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
    02111
    02119     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
    02120
    02128     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02129
    02142     inline Tp::PendingVariant *requestPropertyGroupFlags() const
    02143     {
    02144         return internalRequestProperty(QLatin1String("GroupFlags"));
    02145     }
    02146
    02162     inline Tp::PendingVariant *requestPropertyHandleOwners() const
    02163     {
    02164         return internalRequestProperty(QLatin1String("HandleOwners"));
    02165     }
    02166
    02177     inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
    02178     {
    02179         return internalRequestProperty(QLatin1String("LocalPendingMembers"));
    02180     }
    02181
    02191     inline Tp::PendingVariant *requestPropertyMembers() const
    02192     {
    02193         return internalRequestProperty(QLatin1String("Members"));
    02194     }
    02195
    02206     inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
    02207     {
    02208         return internalRequestProperty(QLatin1String("RemotePendingMembers"));
    02209     }
    02210
    02225     inline Tp::PendingVariant *requestPropertySelfHandle() const
    02226     {
    02227         return internalRequestProperty(QLatin1String("SelfHandle"));
    02228     }
    02229
    02236     Tp::PendingVariantMap *requestAllProperties() const
    02237     {
    02238         return internalRequestAllProperties();
    02239     }
    02240
    02241 public Q_SLOTS:
    02272     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
    02273     {
    02274         if (!invalidationReason().isEmpty()) {
    02275             return QDBusPendingReply<>(QDBusMessage::createError(
    02276                 invalidationReason(),
    02277                 invalidationMessage()
    02278             ));
    02279         }
    02280
    02281         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02282                 this->staticInterfaceName(), QLatin1String("AddMembers"));
    02283         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    02284         return this->connection().asyncCall(callMessage, timeout);
    02285     }
    02286
    02309     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
    02310     {
    02311         if (!invalidationReason().isEmpty()) {
    02312             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
    02313                 invalidationReason(),
    02314                 invalidationMessage()
    02315             ));
    02316         }
    02317
    02318         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02319                 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
    02320         return this->connection().asyncCall(callMessage, timeout);
    02321     }
    02322
    02337     inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
    02338     {
    02339         if (!invalidationReason().isEmpty()) {
    02340             return QDBusPendingReply<uint>(QDBusMessage::createError(
    02341                 invalidationReason(),
    02342                 invalidationMessage()
    02343             ));
    02344         }
    02345
    02346         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02347                 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
    02348         return this->connection().asyncCall(callMessage, timeout);
    02349     }
    02350
    02376     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
    02377     {
    02378         if (!invalidationReason().isEmpty()) {
    02379             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    02380                 invalidationReason(),
    02381                 invalidationMessage()
    02382             ));
    02383         }
    02384
    02385         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02386                 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
    02387         callMessage << QVariant::fromValue(handles);
    02388         return this->connection().asyncCall(callMessage, timeout);
    02389     }
    02390
    02402     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
    02403     {
    02404         if (!invalidationReason().isEmpty()) {
    02405             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    02406                 invalidationReason(),
    02407                 invalidationMessage()
    02408             ));
    02409         }
    02410
    02411         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02412                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
    02413         return this->connection().asyncCall(callMessage, timeout);
    02414     }
    02415
    02434     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
    02435     {
    02436         if (!invalidationReason().isEmpty()) {
    02437             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
    02438                 invalidationReason(),
    02439                 invalidationMessage()
    02440             ));
    02441         }
    02442
    02443         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02444                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
    02445         return this->connection().asyncCall(callMessage, timeout);
    02446     }
    02447
    02458     inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
    02459     {
    02460         if (!invalidationReason().isEmpty()) {
    02461             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    02462                 invalidationReason(),
    02463                 invalidationMessage()
    02464             ));
    02465         }
    02466
    02467         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02468                 this->staticInterfaceName(), QLatin1String("GetMembers"));
    02469         return this->connection().asyncCall(callMessage, timeout);
    02470     }
    02471
    02483     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
    02484     {
    02485         if (!invalidationReason().isEmpty()) {
    02486             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    02487                 invalidationReason(),
    02488                 invalidationMessage()
    02489             ));
    02490         }
    02491
    02492         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02493                 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
    02494         return this->connection().asyncCall(callMessage, timeout);
    02495     }
    02496
    02507     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
    02508     {
    02509         if (!invalidationReason().isEmpty()) {
    02510             return QDBusPendingReply<uint>(QDBusMessage::createError(
    02511                 invalidationReason(),
    02512                 invalidationMessage()
    02513             ));
    02514         }
    02515
    02516         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02517                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
    02518         return this->connection().asyncCall(callMessage, timeout);
    02519     }
    02520
    02576     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
    02577     {
    02578         if (!invalidationReason().isEmpty()) {
    02579             return QDBusPendingReply<>(QDBusMessage::createError(
    02580                 invalidationReason(),
    02581                 invalidationMessage()
    02582             ));
    02583         }
    02584
    02585         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02586                 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
    02587         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    02588         return this->connection().asyncCall(callMessage, timeout);
    02589     }
    02590
    02615     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
    02616     {
    02617         if (!invalidationReason().isEmpty()) {
    02618             return QDBusPendingReply<>(QDBusMessage::createError(
    02619                 invalidationReason(),
    02620                 invalidationMessage()
    02621             ));
    02622         }
    02623
    02624         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02625                 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
    02626         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
    02627         return this->connection().asyncCall(callMessage, timeout);
    02628     }
    02629
    02630 Q_SIGNALS:
    02649     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
    02650
    02660     void SelfHandleChanged(uint selfHandle);
    02661
    02676     void GroupFlagsChanged(uint added, uint removed);
    02677
    02731     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);
    02732
    02841     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
    02842
    02843 protected:
    02844     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02845 };
    02846
    02854 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
    02855 {
    02856     Q_OBJECT
    02857
    02858 public:
    02865     static inline QLatin1String staticInterfaceName()
    02866     {
    02867         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
    02868     }
    02869
    02877     ChannelInterfaceHoldInterface(
    02878         const QString& busName,
    02879         const QString& objectPath,
    02880         QObject* parent = 0
    02881     );
    02882
    02891     ChannelInterfaceHoldInterface(
    02892         const QDBusConnection& connection,
    02893         const QString& busName,
    02894         const QString& objectPath,
    02895         QObject* parent = 0
    02896     );
    02897
    02904     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
    02905
    02913     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
    02914
    02922     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02923
    02930     Tp::PendingVariantMap *requestAllProperties() const
    02931     {
    02932         return internalRequestAllProperties();
    02933     }
    02934
    02935 public Q_SLOTS:
    02954     inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
    02955     {
    02956         if (!invalidationReason().isEmpty()) {
    02957             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
    02958                 invalidationReason(),
    02959                 invalidationMessage()
    02960             ));
    02961         }
    02962
    02963         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02964                 this->staticInterfaceName(), QLatin1String("GetHoldState"));
    02965         return this->connection().asyncCall(callMessage, timeout);
    02966     }
    02967
    03031     inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
    03032     {
    03033         if (!invalidationReason().isEmpty()) {
    03034             return QDBusPendingReply<>(QDBusMessage::createError(
    03035                 invalidationReason(),
    03036                 invalidationMessage()
    03037             ));
    03038         }
    03039
    03040         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03041                 this->staticInterfaceName(), QLatin1String("RequestHold"));
    03042         callMessage << QVariant::fromValue(hold);
    03043         return this->connection().asyncCall(callMessage, timeout);
    03044     }
    03045
    03046 Q_SIGNALS:
    03063     void HoldStateChanged(uint holdState, uint reason);
    03064
    03065 protected:
    03066     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03067 };
    03068
    03076 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
    03077 {
    03078     Q_OBJECT
    03079
    03080 public:
    03087     static inline QLatin1String staticInterfaceName()
    03088     {
    03089         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
    03090     }
    03091
    03099     ChannelInterfaceMediaSignallingInterface(
    03100         const QString& busName,
    03101         const QString& objectPath,
    03102         QObject* parent = 0
    03103     );
    03104
    03113     ChannelInterfaceMediaSignallingInterface(
    03114         const QDBusConnection& connection,
    03115         const QString& busName,
    03116         const QString& objectPath,
    03117         QObject* parent = 0
    03118     );
    03119
    03126     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
    03127
    03135     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
    03136
    03144     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03145
    03152     Tp::PendingVariantMap *requestAllProperties() const
    03153     {
    03154         return internalRequestAllProperties();
    03155     }
    03156
    03157 public Q_SLOTS:
    03169     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
    03170     {
    03171         if (!invalidationReason().isEmpty()) {
    03172             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
    03173                 invalidationReason(),
    03174                 invalidationMessage()
    03175             ));
    03176         }
    03177
    03178         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03179                 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
    03180         return this->connection().asyncCall(callMessage, timeout);
    03181     }
    03182
    03183 Q_SIGNALS:
    03199     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
    03200
    03201 protected:
    03202     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03203 };
    03204
    03212 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
    03213 {
    03214     Q_OBJECT
    03215
    03216 public:
    03223     static inline QLatin1String staticInterfaceName()
    03224     {
    03225         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
    03226     }
    03227
    03235     ChannelInterfaceMessagesInterface(
    03236         const QString& busName,
    03237         const QString& objectPath,
    03238         QObject* parent = 0
    03239     );
    03240
    03249     ChannelInterfaceMessagesInterface(
    03250         const QDBusConnection& connection,
    03251         const QString& busName,
    03252         const QString& objectPath,
    03253         QObject* parent = 0
    03254     );
    03255
    03262     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
    03263
    03271     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
    03272
    03280     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03281
    03335     inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
    03336     {
    03337         return internalRequestProperty(QLatin1String("SupportedContentTypes"));
    03338     }
    03339
    03351     inline Tp::PendingVariant *requestPropertyMessageTypes() const
    03352     {
    03353         return internalRequestProperty(QLatin1String("MessageTypes"));
    03354     }
    03355
    03365     inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
    03366     {
    03367         return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
    03368     }
    03369
    03390     inline Tp::PendingVariant *requestPropertyPendingMessages() const
    03391     {
    03392         return internalRequestProperty(QLatin1String("PendingMessages"));
    03393     }
    03394
    03404     inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
    03405     {
    03406         return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
    03407     }
    03408
    03415     Tp::PendingVariantMap *requestAllProperties() const
    03416     {
    03417         return internalRequestAllProperties();
    03418     }
    03419
    03420 public Q_SLOTS:
    03483     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
    03484     {
    03485         if (!invalidationReason().isEmpty()) {
    03486             return QDBusPendingReply<QString>(QDBusMessage::createError(
    03487                 invalidationReason(),
    03488                 invalidationMessage()
    03489             ));
    03490         }
    03491
    03492         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03493                 this->staticInterfaceName(), QLatin1String("SendMessage"));
    03494         callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
    03495         return this->connection().asyncCall(callMessage, timeout);
    03496     }
    03497
    03538     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
    03539     {
    03540         if (!invalidationReason().isEmpty()) {
    03541             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
    03542                 invalidationReason(),
    03543                 invalidationMessage()
    03544             ));
    03545         }
    03546
    03547         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03548                 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
    03549         callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
    03550         return this->connection().asyncCall(callMessage, timeout);
    03551     }
    03552
    03553 Q_SIGNALS:
    03613     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
    03614
    03628     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
    03629
    03650     void MessageReceived(const Tp::MessagePartList& message);
    03651
    03652 protected:
    03653     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03654 };
    03655
    03663 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
    03664 {
    03665     Q_OBJECT
    03666
    03667 public:
    03674     static inline QLatin1String staticInterfaceName()
    03675     {
    03676         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
    03677     }
    03678
    03686     ChannelInterfacePasswordInterface(
    03687         const QString& busName,
    03688         const QString& objectPath,
    03689         QObject* parent = 0
    03690     );
    03691
    03700     ChannelInterfacePasswordInterface(
    03701         const QDBusConnection& connection,
    03702         const QString& busName,
    03703         const QString& objectPath,
    03704         QObject* parent = 0
    03705     );
    03706
    03713     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
    03714
    03722     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
    03723
    03731     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03732
    03739     Tp::PendingVariantMap *requestAllProperties() const
    03740     {
    03741         return internalRequestAllProperties();
    03742     }
    03743
    03744 public Q_SLOTS:
    03762     inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
    03763     {
    03764         if (!invalidationReason().isEmpty()) {
    03765             return QDBusPendingReply<uint>(QDBusMessage::createError(
    03766                 invalidationReason(),
    03767                 invalidationMessage()
    03768             ));
    03769         }
    03770
    03771         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03772                 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
    03773         return this->connection().asyncCall(callMessage, timeout);
    03774     }
    03775
    03796     inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
    03797     {
    03798         if (!invalidationReason().isEmpty()) {
    03799             return QDBusPendingReply<bool>(QDBusMessage::createError(
    03800                 invalidationReason(),
    03801                 invalidationMessage()
    03802             ));
    03803         }
    03804
    03805         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03806                 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
    03807         callMessage << QVariant::fromValue(password);
    03808         return this->connection().asyncCall(callMessage, timeout);
    03809     }
    03810
    03811 Q_SIGNALS:
    03826     void PasswordFlagsChanged(uint added, uint removed);
    03827
    03828 protected:
    03829     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03830 };
    03831
    03839 class TELEPATHY_QT4_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
    03840 {
    03841     Q_OBJECT
    03842
    03843 public:
    03850     static inline QLatin1String staticInterfaceName()
    03851     {
    03852         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
    03853     }
    03854
    03862     ChannelInterfaceSASLAuthenticationInterface(
    03863         const QString& busName,
    03864         const QString& objectPath,
    03865         QObject* parent = 0
    03866     );
    03867
    03876     ChannelInterfaceSASLAuthenticationInterface(
    03877         const QDBusConnection& connection,
    03878         const QString& busName,
    03879         const QString& objectPath,
    03880         QObject* parent = 0
    03881     );
    03882
    03889     ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
    03890
    03898     explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
    03899
    03907     ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03908
    03931     inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
    03932     {
    03933         return internalRequestProperty(QLatin1String("AvailableMechanisms"));
    03934     }
    03935
    03957     inline Tp::PendingVariant *requestPropertyHasInitialData() const
    03958     {
    03959         return internalRequestProperty(QLatin1String("HasInitialData"));
    03960     }
    03961
    03982     inline Tp::PendingVariant *requestPropertyCanTryAgain() const
    03983     {
    03984         return internalRequestProperty(QLatin1String("CanTryAgain"));
    03985     }
    03986
    04000     inline Tp::PendingVariant *requestPropertySASLStatus() const
    04001     {
    04002         return internalRequestProperty(QLatin1String("SASLStatus"));
    04003     }
    04004
    04033     inline Tp::PendingVariant *requestPropertySASLError() const
    04034     {
    04035         return internalRequestProperty(QLatin1String("SASLError"));
    04036     }
    04037
    04059     inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
    04060     {
    04061         return internalRequestProperty(QLatin1String("SASLErrorDetails"));
    04062     }
    04063
    04128     inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
    04129     {
    04130         return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
    04131     }
    04132
    04194     inline Tp::PendingVariant *requestPropertyDefaultUsername() const
    04195     {
    04196         return internalRequestProperty(QLatin1String("DefaultUsername"));
    04197     }
    04198
    04226     inline Tp::PendingVariant *requestPropertyDefaultRealm() const
    04227     {
    04228         return internalRequestProperty(QLatin1String("DefaultRealm"));
    04229     }
    04230
    04252     inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
    04253     {
    04254         return internalRequestProperty(QLatin1String("MaySaveResponse"));
    04255     }
    04256
    04263     Tp::PendingVariantMap *requestAllProperties() const
    04264     {
    04265         return internalRequestAllProperties();
    04266     }
    04267
    04268 public Q_SLOTS:
    04295     inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
    04296     {
    04297         if (!invalidationReason().isEmpty()) {
    04298             return QDBusPendingReply<>(QDBusMessage::createError(
    04299                 invalidationReason(),
    04300                 invalidationMessage()
    04301             ));
    04302         }
    04303
    04304         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04305                 this->staticInterfaceName(), QLatin1String("StartMechanism"));
    04306         callMessage << QVariant::fromValue(mechanism);
    04307         return this->connection().asyncCall(callMessage, timeout);
    04308     }
    04309
    04364     inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
    04365     {
    04366         if (!invalidationReason().isEmpty()) {
    04367             return QDBusPendingReply<>(QDBusMessage::createError(
    04368                 invalidationReason(),
    04369                 invalidationMessage()
    04370             ));
    04371         }
    04372
    04373         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04374                 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
    04375         callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
    04376         return this->connection().asyncCall(callMessage, timeout);
    04377     }
    04378
    04396     inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
    04397     {
    04398         if (!invalidationReason().isEmpty()) {
    04399             return QDBusPendingReply<>(QDBusMessage::createError(
    04400                 invalidationReason(),
    04401                 invalidationMessage()
    04402             ));
    04403         }
    04404
    04405         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04406                 this->staticInterfaceName(), QLatin1String("Respond"));
    04407         callMessage << QVariant::fromValue(responseData);
    04408         return this->connection().asyncCall(callMessage, timeout);
    04409     }
    04410
    04439     inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
    04440     {
    04441         if (!invalidationReason().isEmpty()) {
    04442             return QDBusPendingReply<>(QDBusMessage::createError(
    04443                 invalidationReason(),
    04444                 invalidationMessage()
    04445             ));
    04446         }
    04447
    04448         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04449                 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
    04450         return this->connection().asyncCall(callMessage, timeout);
    04451     }
    04452
    04481     inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
    04482     {
    04483         if (!invalidationReason().isEmpty()) {
    04484             return QDBusPendingReply<>(QDBusMessage::createError(
    04485                 invalidationReason(),
    04486                 invalidationMessage()
    04487             ));
    04488         }
    04489
    04490         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04491                 this->staticInterfaceName(), QLatin1String("AbortSASL"));
    04492         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
    04493         return this->connection().asyncCall(callMessage, timeout);
    04494     }
    04495
    04496 Q_SIGNALS:
    04514     void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
    04515
    04535     void NewChallenge(const QByteArray& challengeData);
    04536
    04537 protected:
    04538     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04539 };
    04540
    04548 class TELEPATHY_QT4_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
    04549 {
    04550     Q_OBJECT
    04551
    04552 public:
    04559     static inline QLatin1String staticInterfaceName()
    04560     {
    04561         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
    04562     }
    04563
    04571     ChannelInterfaceSecurableInterface(
    04572         const QString& busName,
    04573         const QString& objectPath,
    04574         QObject* parent = 0
    04575     );
    04576
    04585     ChannelInterfaceSecurableInterface(
    04586         const QDBusConnection& connection,
    04587         const QString& busName,
    04588         const QString& objectPath,
    04589         QObject* parent = 0
    04590     );
    04591
    04598     ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
    04599
    04607     explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
    04608
    04616     ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04617
    04639     inline Tp::PendingVariant *requestPropertyEncrypted() const
    04640     {
    04641         return internalRequestProperty(QLatin1String("Encrypted"));
    04642     }
    04643
    04660     inline Tp::PendingVariant *requestPropertyVerified() const
    04661     {
    04662         return internalRequestProperty(QLatin1String("Verified"));
    04663     }
    04664
    04671     Tp::PendingVariantMap *requestAllProperties() const
    04672     {
    04673         return internalRequestAllProperties();
    04674     }
    04675
    04676 protected:
    04677     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04678 };
    04679
    04687 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
    04688 {
    04689     Q_OBJECT
    04690
    04691 public:
    04698     static inline QLatin1String staticInterfaceName()
    04699     {
    04700         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
    04701     }
    04702
    04710     ChannelInterfaceServicePointInterface(
    04711         const QString& busName,
    04712         const QString& objectPath,
    04713         QObject* parent = 0
    04714     );
    04715
    04724     ChannelInterfaceServicePointInterface(
    04725         const QDBusConnection& connection,
    04726         const QString& busName,
    04727         const QString& objectPath,
    04728         QObject* parent = 0
    04729     );
    04730
    04737     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
    04738
    04746     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
    04747
    04755     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04756
    04776     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
    04777     {
    04778         return internalRequestProperty(QLatin1String("InitialServicePoint"));
    04779     }
    04780
    04793     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
    04794     {
    04795         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
    04796     }
    04797
    04804     Tp::PendingVariantMap *requestAllProperties() const
    04805     {
    04806         return internalRequestAllProperties();
    04807     }
    04808
    04809 Q_SIGNALS:
    04826     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
    04827
    04828 protected:
    04829     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04830 };
    04831
    04839 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
    04840 {
    04841     Q_OBJECT
    04842
    04843 public:
    04850     static inline QLatin1String staticInterfaceName()
    04851     {
    04852         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
    04853     }
    04854
    04862     ChannelInterfaceTubeInterface(
    04863         const QString& busName,
    04864         const QString& objectPath,
    04865         QObject* parent = 0
    04866     );
    04867
    04876     ChannelInterfaceTubeInterface(
    04877         const QDBusConnection& connection,
    04878         const QString& busName,
    04879         const QString& objectPath,
    04880         QObject* parent = 0
    04881     );
    04882
    04889     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
    04890
    04898     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    04899
    04907     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04908
    04954     inline Tp::PendingVariant *requestPropertyParameters() const
    04955     {
    04956         return internalRequestProperty(QLatin1String("Parameters"));
    04957     }
    04958
    04974     inline Tp::PendingVariant *requestPropertyState() const
    04975     {
    04976         return internalRequestProperty(QLatin1String("State"));
    04977     }
    04978
    04985     Tp::PendingVariantMap *requestAllProperties() const
    04986     {
    04987         return internalRequestAllProperties();
    04988     }
    04989
    04990 Q_SIGNALS:
    05001     void TubeChannelStateChanged(uint state);
    05002
    05003 protected:
    05004     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05005 };
    05006
    05014 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
    05015 {
    05016     Q_OBJECT
    05017
    05018 public:
    05025     static inline QLatin1String staticInterfaceName()
    05026     {
    05027         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
    05028     }
    05029
    05037     ChannelTypeContactListInterface(
    05038         const QString& busName,
    05039         const QString& objectPath,
    05040         QObject* parent = 0
    05041     );
    05042
    05051     ChannelTypeContactListInterface(
    05052         const QDBusConnection& connection,
    05053         const QString& busName,
    05054         const QString& objectPath,
    05055         QObject* parent = 0
    05056     );
    05057
    05064     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
    05065
    05073     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
    05074
    05082     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05083
    05090     Tp::PendingVariantMap *requestAllProperties() const
    05091     {
    05092         return internalRequestAllProperties();
    05093     }
    05094
    05095 protected:
    05096     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05097 };
    05098
    05106 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
    05107 {
    05108     Q_OBJECT
    05109
    05110 public:
    05117     static inline QLatin1String staticInterfaceName()
    05118     {
    05119         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
    05120     }
    05121
    05129     ChannelTypeContactSearchInterface(
    05130         const QString& busName,
    05131         const QString& objectPath,
    05132         QObject* parent = 0
    05133     );
    05134
    05143     ChannelTypeContactSearchInterface(
    05144         const QDBusConnection& connection,
    05145         const QString& busName,
    05146         const QString& objectPath,
    05147         QObject* parent = 0
    05148     );
    05149
    05156     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
    05157
    05165     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
    05166
    05174     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05175
    05186     inline Tp::PendingVariant *requestPropertySearchState() const
    05187     {
    05188         return internalRequestProperty(QLatin1String("SearchState"));
    05189     }
    05190
    05216     inline Tp::PendingVariant *requestPropertyLimit() const
    05217     {
    05218         return internalRequestProperty(QLatin1String("Limit"));
    05219     }
    05220
    05235     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
    05236     {
    05237         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
    05238     }
    05239
    05260     inline Tp::PendingVariant *requestPropertyServer() const
    05261     {
    05262         return internalRequestProperty(QLatin1String("Server"));
    05263     }
    05264
    05271     Tp::PendingVariantMap *requestAllProperties() const
    05272     {
    05273         return internalRequestAllProperties();
    05274     }
    05275
    05276 public Q_SLOTS:
    05294     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
    05295     {
    05296         if (!invalidationReason().isEmpty()) {
    05297             return QDBusPendingReply<>(QDBusMessage::createError(
    05298                 invalidationReason(),
    05299                 invalidationMessage()
    05300             ));
    05301         }
    05302
    05303         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05304                 this->staticInterfaceName(), QLatin1String("Search"));
    05305         callMessage << QVariant::fromValue(terms);
    05306         return this->connection().asyncCall(callMessage, timeout);
    05307     }
    05308
    05323     inline QDBusPendingReply<> More(int timeout = -1)
    05324     {
    05325         if (!invalidationReason().isEmpty()) {
    05326             return QDBusPendingReply<>(QDBusMessage::createError(
    05327                 invalidationReason(),
    05328                 invalidationMessage()
    05329             ));
    05330         }
    05331
    05332         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05333                 this->staticInterfaceName(), QLatin1String("More"));
    05334         return this->connection().asyncCall(callMessage, timeout);
    05335     }
    05336
    05369     inline QDBusPendingReply<> Stop(int timeout = -1)
    05370     {
    05371         if (!invalidationReason().isEmpty()) {
    05372             return QDBusPendingReply<>(QDBusMessage::createError(
    05373                 invalidationReason(),
    05374                 invalidationMessage()
    05375             ));
    05376         }
    05377
    05378         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05379                 this->staticInterfaceName(), QLatin1String("Stop"));
    05380         return this->connection().asyncCall(callMessage, timeout);
    05381     }
    05382
    05383 Q_SIGNALS:
    05433     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
    05434
    05447     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
    05448
    05449 protected:
    05450     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05451 };
    05452
    05460 class TELEPATHY_QT4_EXPORT ChannelTypeDBusTubeInterface : public Tp::AbstractInterface
    05461 {
    05462     Q_OBJECT
    05463
    05464 public:
    05471     static inline QLatin1String staticInterfaceName()
    05472     {
    05473         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.DBusTube");
    05474     }
    05475
    05483     ChannelTypeDBusTubeInterface(
    05484         const QString& busName,
    05485         const QString& objectPath,
    05486         QObject* parent = 0
    05487     );
    05488
    05497     ChannelTypeDBusTubeInterface(
    05498         const QDBusConnection& connection,
    05499         const QString& busName,
    05500         const QString& objectPath,
    05501         QObject* parent = 0
    05502     );
    05503
    05510     ChannelTypeDBusTubeInterface(Tp::DBusProxy *proxy);
    05511
    05519     explicit ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    05520
    05528     ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05529
    05548     inline Tp::PendingVariant *requestPropertyServiceName() const
    05549     {
    05550         return internalRequestProperty(QLatin1String("ServiceName"));
    05551     }
    05552
    05565     inline Tp::PendingVariant *requestPropertyDBusNames() const
    05566     {
    05567         return internalRequestProperty(QLatin1String("DBusNames"));
    05568     }
    05569
    05587     inline Tp::PendingVariant *requestPropertySupportedAccessControls() const
    05588     {
    05589         return internalRequestProperty(QLatin1String("SupportedAccessControls"));
    05590     }
    05591
    05598     Tp::PendingVariantMap *requestAllProperties() const
    05599     {
    05600         return internalRequestAllProperties();
    05601     }
    05602
    05603 public Q_SLOTS:
    05628     inline QDBusPendingReply<QString> Offer(const QVariantMap& parameters, uint accesscontrol, int timeout = -1)
    05629     {
    05630         if (!invalidationReason().isEmpty()) {
    05631             return QDBusPendingReply<QString>(QDBusMessage::createError(
    05632                 invalidationReason(),
    05633                 invalidationMessage()
    05634             ));
    05635         }
    05636
    05637         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05638                 this->staticInterfaceName(), QLatin1String("Offer"));
    05639         callMessage << QVariant::fromValue(parameters) << QVariant::fromValue(accesscontrol);
    05640         return this->connection().asyncCall(callMessage, timeout);
    05641     }
    05642
    05666     inline QDBusPendingReply<QString> Accept(uint accesscontrol, int timeout = -1)
    05667     {
    05668         if (!invalidationReason().isEmpty()) {
    05669             return QDBusPendingReply<QString>(QDBusMessage::createError(
    05670                 invalidationReason(),
    05671                 invalidationMessage()
    05672             ));
    05673         }
    05674
    05675         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05676                 this->staticInterfaceName(), QLatin1String("Accept"));
    05677         callMessage << QVariant::fromValue(accesscontrol);
    05678         return this->connection().asyncCall(callMessage, timeout);
    05679     }
    05680
    05681 Q_SIGNALS:
    05697     void DBusNamesChanged(const Tp::DBusTubeParticipants& added, const Tp::UIntList& removed);
    05698
    05699 protected:
    05700     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05701 };
    05702
    05710 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
    05711 {
    05712     Q_OBJECT
    05713
    05714 public:
    05721     static inline QLatin1String staticInterfaceName()
    05722     {
    05723         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
    05724     }
    05725
    05733     ChannelTypeFileTransferInterface(
    05734         const QString& busName,
    05735         const QString& objectPath,
    05736         QObject* parent = 0
    05737     );
    05738
    05747     ChannelTypeFileTransferInterface(
    05748         const QDBusConnection& connection,
    05749         const QString& busName,
    05750         const QString& objectPath,
    05751         QObject* parent = 0
    05752     );
    05753
    05760     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
    05761
    05769     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
    05770
    05778     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05779
    05792     inline Tp::PendingVariant *requestPropertyState() const
    05793     {
    05794         return internalRequestProperty(QLatin1String("State"));
    05795     }
    05796
    05814     inline Tp::PendingVariant *requestPropertyContentType() const
    05815     {
    05816         return internalRequestProperty(QLatin1String("ContentType"));
    05817     }
    05818
    05840     inline Tp::PendingVariant *requestPropertyFilename() const
    05841     {
    05842         return internalRequestProperty(QLatin1String("Filename"));
    05843     }
    05844
    05868     inline Tp::PendingVariant *requestPropertySize() const
    05869     {
    05870         return internalRequestProperty(QLatin1String("Size"));
    05871     }
    05872
    05899     inline Tp::PendingVariant *requestPropertyContentHashType() const
    05900     {
    05901         return internalRequestProperty(QLatin1String("ContentHashType"));
    05902     }
    05903
    05924     inline Tp::PendingVariant *requestPropertyContentHash() const
    05925     {
    05926         return internalRequestProperty(QLatin1String("ContentHash"));
    05927     }
    05928
    05946     inline Tp::PendingVariant *requestPropertyDescription() const
    05947     {
    05948         return internalRequestProperty(QLatin1String("Description"));
    05949     }
    05950
    05967     inline Tp::PendingVariant *requestPropertyDate() const
    05968     {
    05969         return internalRequestProperty(QLatin1String("Date"));
    05970     }
    05971
    06000     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
    06001     {
    06002         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
    06003     }
    06004
    06018     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
    06019     {
    06020         return internalRequestProperty(QLatin1String("TransferredBytes"));
    06021     }
    06022
    06045     inline Tp::PendingVariant *requestPropertyInitialOffset() const
    06046     {
    06047         return internalRequestProperty(QLatin1String("InitialOffset"));
    06048     }
    06049
    06084     inline Tp::PendingVariant *requestPropertyURI() const
    06085     {
    06086         return internalRequestProperty(QLatin1String("URI"));
    06087     }
    06088
    06123     inline Tp::PendingOperation *setPropertyURI(QString newValue)
    06124     {
    06125         return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
    06126     }
    06127
    06134     Tp::PendingVariantMap *requestAllProperties() const
    06135     {
    06136         return internalRequestAllProperties();
    06137     }
    06138
    06139 public Q_SLOTS:
    06184     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
    06185     {
    06186         if (!invalidationReason().isEmpty()) {
    06187             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    06188                 invalidationReason(),
    06189                 invalidationMessage()
    06190             ));
    06191         }
    06192
    06193         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06194                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
    06195         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
    06196         return this->connection().asyncCall(callMessage, timeout);
    06197     }
    06198
    06232     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
    06233     {
    06234         if (!invalidationReason().isEmpty()) {
    06235             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    06236                 invalidationReason(),
    06237                 invalidationMessage()
    06238             ));
    06239         }
    06240
    06241         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06242                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
    06243         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    06244         return this->connection().asyncCall(callMessage, timeout);
    06245     }
    06246
    06247 Q_SIGNALS:
    06265     void FileTransferStateChanged(uint state, uint reason);
    06266
    06279     void TransferredBytesChanged(qulonglong count);
    06280
    06292     void InitialOffsetDefined(qulonglong initialOffset);
    06293
    06305     void URIDefined(const QString& URI);
    06306
    06307 protected:
    06308     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06309 };
    06310
    06318 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
    06319 {
    06320     Q_OBJECT
    06321
    06322 public:
    06329     static inline QLatin1String staticInterfaceName()
    06330     {
    06331         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
    06332     }
    06333
    06341     ChannelTypeRoomListInterface(
    06342         const QString& busName,
    06343         const QString& objectPath,
    06344         QObject* parent = 0
    06345     );
    06346
    06355     ChannelTypeRoomListInterface(
    06356         const QDBusConnection& connection,
    06357         const QString& busName,
    06358         const QString& objectPath,
    06359         QObject* parent = 0
    06360     );
    06361
    06368     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
    06369
    06377     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
    06378
    06386     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    06387
    06401     inline Tp::PendingVariant *requestPropertyServer() const
    06402     {
    06403         return internalRequestProperty(QLatin1String("Server"));
    06404     }
    06405
    06412     Tp::PendingVariantMap *requestAllProperties() const
    06413     {
    06414         return internalRequestAllProperties();
    06415     }
    06416
    06417 public Q_SLOTS:
    06433     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
    06434     {
    06435         if (!invalidationReason().isEmpty()) {
    06436             return QDBusPendingReply<bool>(QDBusMessage::createError(
    06437                 invalidationReason(),
    06438                 invalidationMessage()
    06439             ));
    06440         }
    06441
    06442         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06443                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
    06444         return this->connection().asyncCall(callMessage, timeout);
    06445     }
    06446
    06460     inline QDBusPendingReply<> ListRooms(int timeout = -1)
    06461     {
    06462         if (!invalidationReason().isEmpty()) {
    06463             return QDBusPendingReply<>(QDBusMessage::createError(
    06464                 invalidationReason(),
    06465                 invalidationMessage()
    06466             ));
    06467         }
    06468
    06469         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06470                 this->staticInterfaceName(), QLatin1String("ListRooms"));
    06471         return this->connection().asyncCall(callMessage, timeout);
    06472     }
    06473
    06486     inline QDBusPendingReply<> StopListing(int timeout = -1)
    06487     {
    06488         if (!invalidationReason().isEmpty()) {
    06489             return QDBusPendingReply<>(QDBusMessage::createError(
    06490                 invalidationReason(),
    06491                 invalidationMessage()
    06492             ));
    06493         }
    06494
    06495         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06496                 this->staticInterfaceName(), QLatin1String("StopListing"));
    06497         return this->connection().asyncCall(callMessage, timeout);
    06498     }
    06499
    06500 Q_SIGNALS:
    06558     void GotRooms(const Tp::RoomInfoList& rooms);
    06559
    06570     void ListingRooms(bool listing);
    06571
    06572 protected:
    06573     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06574 };
    06575
    06583 class TELEPATHY_QT4_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
    06584 {
    06585     Q_OBJECT
    06586
    06587 public:
    06594     static inline QLatin1String staticInterfaceName()
    06595     {
    06596         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
    06597     }
    06598
    06606     ChannelTypeServerAuthenticationInterface(
    06607         const QString& busName,
    06608         const QString& objectPath,
    06609         QObject* parent = 0
    06610     );
    06611
    06620     ChannelTypeServerAuthenticationInterface(
    06621         const QDBusConnection& connection,
    06622         const QString& busName,
    06623         const QString& objectPath,
    06624         QObject* parent = 0
    06625     );
    06626
    06633     ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
    06634
    06642     explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
    06643
    06651     ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    06652
    06669     inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
    06670     {
    06671         return internalRequestProperty(QLatin1String("AuthenticationMethod"));
    06672     }
    06673
    06680     Tp::PendingVariantMap *requestAllProperties() const
    06681     {
    06682         return internalRequestAllProperties();
    06683     }
    06684
    06685 protected:
    06686     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06687 };
    06688
    06696 class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
    06697 {
    06698     Q_OBJECT
    06699
    06700 public:
    06707     static inline QLatin1String staticInterfaceName()
    06708     {
    06709         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
    06710     }
    06711
    06719     ChannelTypeServerTLSConnectionInterface(
    06720         const QString& busName,
    06721         const QString& objectPath,
    06722         QObject* parent = 0
    06723     );
    06724
    06733     ChannelTypeServerTLSConnectionInterface(
    06734         const QDBusConnection& connection,
    06735         const QString& busName,
    06736         const QString& objectPath,
    06737         QObject* parent = 0
    06738     );
    06739
    06746     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
    06747
    06755     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
    06756
    06764     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    06765
    06776     inline Tp::PendingVariant *requestPropertyServerCertificate() const
    06777     {
    06778         return internalRequestProperty(QLatin1String("ServerCertificate"));
    06779     }
    06780
    06794     inline Tp::PendingVariant *requestPropertyHostname() const
    06795     {
    06796         return internalRequestProperty(QLatin1String("Hostname"));
    06797     }
    06798
    06825     inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
    06826     {
    06827         return internalRequestProperty(QLatin1String("ReferenceIdentities"));
    06828     }
    06829
    06836     Tp::PendingVariantMap *requestAllProperties() const
    06837     {
    06838         return internalRequestAllProperties();
    06839     }
    06840
    06841 protected:
    06842     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06843 };
    06844
    06852 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
    06853 {
    06854     Q_OBJECT
    06855
    06856 public:
    06863     static inline QLatin1String staticInterfaceName()
    06864     {
    06865         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
    06866     }
    06867
    06875     ChannelTypeStreamTubeInterface(
    06876         const QString& busName,
    06877         const QString& objectPath,
    06878         QObject* parent = 0
    06879     );
    06880
    06889     ChannelTypeStreamTubeInterface(
    06890         const QDBusConnection& connection,
    06891         const QString& busName,
    06892         const QString& objectPath,
    06893         QObject* parent = 0
    06894     );
    06895
    06902     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
    06903
    06911     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    06912
    06920     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    06921
    06944     inline Tp::PendingVariant *requestPropertyService() const
    06945     {
    06946         return internalRequestProperty(QLatin1String("Service"));
    06947     }
    06948
    06983     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
    06984     {
    06985         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
    06986     }
    06987
    06994     Tp::PendingVariantMap *requestAllProperties() const
    06995     {
    06996         return internalRequestAllProperties();
    06997     }
    06998
    06999 public Q_SLOTS:
    07030     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
    07031     {
    07032         if (!invalidationReason().isEmpty()) {
    07033             return QDBusPendingReply<>(QDBusMessage::createError(
    07034                 invalidationReason(),
    07035                 invalidationMessage()
    07036             ));
    07037         }
    07038
    07039         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07040                 this->staticInterfaceName(), QLatin1String("Offer"));
    07041         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
    07042         return this->connection().asyncCall(callMessage, timeout);
    07043     }
    07044
    07085     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
    07086     {
    07087         if (!invalidationReason().isEmpty()) {
    07088             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    07089                 invalidationReason(),
    07090                 invalidationMessage()
    07091             ));
    07092         }
    07093
    07094         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07095                 this->staticInterfaceName(), QLatin1String("Accept"));
    07096         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
    07097         return this->connection().asyncCall(callMessage, timeout);
    07098     }
    07099
    07100 Q_SIGNALS:
    07141     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
    07142
    07158     void NewLocalConnection(uint connectionID);
    07159
    07191     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
    07192
    07193 protected:
    07194     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07195 };
    07196
    07204 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
    07205 {
    07206     Q_OBJECT
    07207
    07208 public:
    07215     static inline QLatin1String staticInterfaceName()
    07216     {
    07217         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
    07218     }
    07219
    07227     ChannelTypeStreamedMediaInterface(
    07228         const QString& busName,
    07229         const QString& objectPath,
    07230         QObject* parent = 0
    07231     );
    07232
    07241     ChannelTypeStreamedMediaInterface(
    07242         const QDBusConnection& connection,
    07243         const QString& busName,
    07244         const QString& objectPath,
    07245         QObject* parent = 0
    07246     );
    07247
    07254     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
    07255
    07263     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
    07264
    07272     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    07273
    07362     inline Tp::PendingVariant *requestPropertyInitialAudio() const
    07363     {
    07364         return internalRequestProperty(QLatin1String("InitialAudio"));
    07365     }
    07366
    07387     inline Tp::PendingVariant *requestPropertyInitialVideo() const
    07388     {
    07389         return internalRequestProperty(QLatin1String("InitialVideo"));
    07390     }
    07391
    07434     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
    07435     {
    07436         return internalRequestProperty(QLatin1String("ImmutableStreams"));
    07437     }
    07438
    07445     Tp::PendingVariantMap *requestAllProperties() const
    07446     {
    07447         return internalRequestAllProperties();
    07448     }
    07449
    07450 public Q_SLOTS:
    07478     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
    07479     {
    07480         if (!invalidationReason().isEmpty()) {
    07481             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    07482                 invalidationReason(),
    07483                 invalidationMessage()
    07484             ));
    07485         }
    07486
    07487         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07488                 this->staticInterfaceName(), QLatin1String("ListStreams"));
    07489         return this->connection().asyncCall(callMessage, timeout);
    07490     }
    07491
    07518     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
    07519     {
    07520         if (!invalidationReason().isEmpty()) {
    07521             return QDBusPendingReply<>(QDBusMessage::createError(
    07522                 invalidationReason(),
    07523                 invalidationMessage()
    07524             ));
    07525         }
    07526
    07527         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07528                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
    07529         callMessage << QVariant::fromValue(streams);
    07530         return this->connection().asyncCall(callMessage, timeout);
    07531     }
    07532
    07569     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
    07570     {
    07571         if (!invalidationReason().isEmpty()) {
    07572             return QDBusPendingReply<>(QDBusMessage::createError(
    07573                 invalidationReason(),
    07574                 invalidationMessage()
    07575             ));
    07576         }
    07577
    07578         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07579                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
    07580         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
    07581         return this->connection().asyncCall(callMessage, timeout);
    07582     }
    07583
    07636     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
    07637     {
    07638         if (!invalidationReason().isEmpty()) {
    07639             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    07640                 invalidationReason(),
    07641                 invalidationMessage()
    07642             ));
    07643         }
    07644
    07645         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07646                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
    07647         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
    07648         return this->connection().asyncCall(callMessage, timeout);
    07649     }
    07650
    07651 Q_SIGNALS:
    07718     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
    07719
    07751     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
    07752
    07770     void StreamError(uint streamID, uint errorCode, const QString& message);
    07771
    07781     void StreamRemoved(uint streamID);
    07782
    07796     void StreamStateChanged(uint streamID, uint streamState);
    07797
    07798 protected:
    07799     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07800 };
    07801
    07809 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
    07810 {
    07811     Q_OBJECT
    07812
    07813 public:
    07820     static inline QLatin1String staticInterfaceName()
    07821     {
    07822         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
    07823     }
    07824
    07832     ChannelTypeTextInterface(
    07833         const QString& busName,
    07834         const QString& objectPath,
    07835         QObject* parent = 0
    07836     );
    07837
    07846     ChannelTypeTextInterface(
    07847         const QDBusConnection& connection,
    07848         const QString& busName,
    07849         const QString& objectPath,
    07850         QObject* parent = 0
    07851     );
    07852
    07859     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
    07860
    07868     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
    07869
    07877     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    07878
    07885     Tp::PendingVariantMap *requestAllProperties() const
    07886     {
    07887         return internalRequestAllProperties();
    07888     }
    07889
    07890 public Q_SLOTS:
    07906     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
    07907     {
    07908         if (!invalidationReason().isEmpty()) {
    07909             return QDBusPendingReply<>(QDBusMessage::createError(
    07910                 invalidationReason(),
    07911                 invalidationMessage()
    07912             ));
    07913         }
    07914
    07915         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07916                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
    07917         callMessage << QVariant::fromValue(IDs);
    07918         return this->connection().asyncCall(callMessage, timeout);
    07919     }
    07920
    07936     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
    07937     {
    07938         if (!invalidationReason().isEmpty()) {
    07939             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    07940                 invalidationReason(),
    07941                 invalidationMessage()
    07942             ));
    07943         }
    07944
    07945         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07946                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
    07947         return this->connection().asyncCall(callMessage, timeout);
    07948     }
    07949
    07980     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
    07981     {
    07982         if (!invalidationReason().isEmpty()) {
    07983             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
    07984                 invalidationReason(),
    07985                 invalidationMessage()
    07986             ));
    07987         }
    07988
    07989         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07990                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
    07991         callMessage << QVariant::fromValue(clear);
    07992         return this->connection().asyncCall(callMessage, timeout);
    07993     }
    07994
    08027     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
    08028     {
    08029         if (!invalidationReason().isEmpty()) {
    08030             return QDBusPendingReply<>(QDBusMessage::createError(
    08031                 invalidationReason(),
    08032                 invalidationMessage()
    08033             ));
    08034         }
    08035
    08036         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08037                 this->staticInterfaceName(), QLatin1String("Send"));
    08038         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
    08039         return this->connection().asyncCall(callMessage, timeout);
    08040     }
    08041
    08042 Q_SIGNALS:
    08050     void LostMessage();
    08051
    08085     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
    08086
    08115     void SendError(uint error, uint timestamp, uint type, const QString& text);
    08116
    08140     void Sent(uint timestamp, uint type, const QString& text);
    08141
    08142 protected:
    08143     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    08144 };
    08145
    08153 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
    08154 {
    08155     Q_OBJECT
    08156
    08157 public:
    08164     static inline QLatin1String staticInterfaceName()
    08165     {
    08166         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
    08167     }
    08168
    08176     ChannelTypeTubesInterface(
    08177         const QString& busName,
    08178         const QString& objectPath,
    08179         QObject* parent = 0
    08180     );
    08181
    08190     ChannelTypeTubesInterface(
    08191         const QDBusConnection& connection,
    08192         const QString& busName,
    08193         const QString& objectPath,
    08194         QObject* parent = 0
    08195     );
    08196
    08203     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
    08204
    08212     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
    08213
    08221     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    08222
    08229     Tp::PendingVariantMap *requestAllProperties() const
    08230     {
    08231         return internalRequestAllProperties();
    08232     }
    08233
    08234 public Q_SLOTS:
    08271     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
    08272     {
    08273         if (!invalidationReason().isEmpty()) {
    08274             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
    08275                 invalidationReason(),
    08276                 invalidationMessage()
    08277             ));
    08278         }
    08279
    08280         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08281                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
    08282         return this->connection().asyncCall(callMessage, timeout);
    08283     }
    08284
    08298     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
    08299     {
    08300         if (!invalidationReason().isEmpty()) {
    08301             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    08302                 invalidationReason(),
    08303                 invalidationMessage()
    08304             ));
    08305         }
    08306
    08307         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08308                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
    08309         return this->connection().asyncCall(callMessage, timeout);
    08310     }
    08311
    08327     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
    08328     {
    08329         if (!invalidationReason().isEmpty()) {
    08330             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
    08331                 invalidationReason(),
    08332                 invalidationMessage()
    08333             ));
    08334         }
    08335
    08336         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08337                 this->staticInterfaceName(), QLatin1String("ListTubes"));
    08338         return this->connection().asyncCall(callMessage, timeout);
    08339     }
    08340
    08368     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
    08369     {
    08370         if (!invalidationReason().isEmpty()) {
    08371             return QDBusPendingReply<uint>(QDBusMessage::createError(
    08372                 invalidationReason(),
    08373                 invalidationMessage()
    08374             ));
    08375         }
    08376
    08377         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08378                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
    08379         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
    08380         return this->connection().asyncCall(callMessage, timeout);
    08381     }
    08382
    08442     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
    08443     {
    08444         if (!invalidationReason().isEmpty()) {
    08445             return QDBusPendingReply<uint>(QDBusMessage::createError(
    08446                 invalidationReason(),
    08447                 invalidationMessage()
    08448             ));
    08449         }
    08450
    08451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08452                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
    08453         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    08454         return this->connection().asyncCall(callMessage, timeout);
    08455     }
    08456
    08479     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
    08480     {
    08481         if (!invalidationReason().isEmpty()) {
    08482             return QDBusPendingReply<QString>(QDBusMessage::createError(
    08483                 invalidationReason(),
    08484                 invalidationMessage()
    08485             ));
    08486         }
    08487
    08488         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08489                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
    08490         callMessage << QVariant::fromValue(ID);
    08491         return this->connection().asyncCall(callMessage, timeout);
    08492     }
    08493
    08531     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
    08532     {
    08533         if (!invalidationReason().isEmpty()) {
    08534             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    08535                 invalidationReason(),
    08536                 invalidationMessage()
    08537             ));
    08538         }
    08539
    08540         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08541                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
    08542         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    08543         return this->connection().asyncCall(callMessage, timeout);
    08544     }
    08545
    08560     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
    08561     {
    08562         if (!invalidationReason().isEmpty()) {
    08563             return QDBusPendingReply<>(QDBusMessage::createError(
    08564                 invalidationReason(),
    08565                 invalidationMessage()
    08566             ));
    08567         }
    08568
    08569         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08570                 this->staticInterfaceName(), QLatin1String("CloseTube"));
    08571         callMessage << QVariant::fromValue(ID);
    08572         return this->connection().asyncCall(callMessage, timeout);
    08573     }
    08574
    08594     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
    08595     {
    08596         if (!invalidationReason().isEmpty()) {
    08597             return QDBusPendingReply<QString>(QDBusMessage::createError(
    08598                 invalidationReason(),
    08599                 invalidationMessage()
    08600             ));
    08601         }
    08602
    08603         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08604                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
    08605         callMessage << QVariant::fromValue(ID);
    08606         return this->connection().asyncCall(callMessage, timeout);
    08607     }
    08608
    08629     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
    08630     {
    08631         if (!invalidationReason().isEmpty()) {
    08632             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
    08633                 invalidationReason(),
    08634                 invalidationMessage()
    08635             ));
    08636         }
    08637
    08638         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08639                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
    08640         callMessage << QVariant::fromValue(ID);
    08641         return this->connection().asyncCall(callMessage, timeout);
    08642     }
    08643
    08669     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
    08670     {
    08671         if (!invalidationReason().isEmpty()) {
    08672             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
    08673                 invalidationReason(),
    08674                 invalidationMessage()
    08675             ));
    08676         }
    08677
    08678         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08679                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
    08680         callMessage << QVariant::fromValue(ID);
    08681         return this->connection().asyncCall(callMessage, timeout);
    08682     }
    08683
    08684 Q_SIGNALS:
    08714     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
    08715
    08729     void TubeStateChanged(uint ID, uint state);
    08730
    08741     void TubeClosed(uint ID);
    08742
    08761     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
    08762
    08777     void StreamTubeNewConnection(uint ID, uint handle);
    08778
    08779 protected:
    08780     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    08781 };
    08782 }
    08783 }
    08784 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
    08785 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
    08786 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
    08787 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
    08788 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
    08789 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
    08790 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDestroyableInterface*)
    08791 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
    08792 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
    08793 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
    08794 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
    08795 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
    08796 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
    08797 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
    08798 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
    08799 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
    08800 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
    08801 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
    08802 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeDBusTubeInterface*)
    08803 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
    08804 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
    08805 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
    08806 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
    08807 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
    08808 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
    08809 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
    08810 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)