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

cli-channel.h

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