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

cli-channel.h

00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
00003  *
00004  * This file can be distributed under the same terms as the specification from
00005  * which it was generated.
00006  */
00007 
00008 #ifndef IN_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011 
00012 #include <TelepathyQt4/Types>
00013 
00014 #include <QtGlobal>
00015 
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019 
00020 #include <QDBusPendingReply>
00021 
00022 #include <TelepathyQt4/AbstractInterface>
00023 #include <TelepathyQt4/DBusProxy>
00024 #include <TelepathyQt4/Global>
00025 
00026 namespace Tp
00027 {
00028 class PendingVariant;
00029 class PendingOperation;
00030 }
00031 
00032 namespace Tp
00033 {
00034 namespace Client
00035 {
00036 
00044 class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
00045 {
00046     Q_OBJECT
00047 
00048 public:
00055     static inline QLatin1String staticInterfaceName()
00056     {
00057         return QLatin1String("org.freedesktop.Telepathy.Channel");
00058     }
00059 
00067     ChannelInterface(
00068         const QString& busName,
00069         const QString& objectPath,
00070         QObject* parent = 0
00071     );
00072 
00081     ChannelInterface(
00082         const QDBusConnection& connection,
00083         const QString& busName,
00084         const QString& objectPath,
00085         QObject* parent = 0
00086     );
00087 
00094     ChannelInterface(Tp::DBusProxy *proxy);
00095 
00124     inline Tp::PendingVariant *requestPropertyChannelType() const
00125     {
00126         return internalRequestProperty(QLatin1String("ChannelType"));
00127     }
00128 
00160     inline Tp::PendingVariant *requestPropertyInterfaces() const
00161     {
00162         return internalRequestProperty(QLatin1String("Interfaces"));
00163     }
00164 
00207     inline Tp::PendingVariant *requestPropertyTargetHandle() const
00208     {
00209         return internalRequestProperty(QLatin1String("TargetHandle"));
00210     }
00211 
00263     inline Tp::PendingVariant *requestPropertyTargetID() const
00264     {
00265         return internalRequestProperty(QLatin1String("TargetID"));
00266     }
00267 
00285     inline Tp::PendingVariant *requestPropertyTargetHandleType() const
00286     {
00287         return internalRequestProperty(QLatin1String("TargetHandleType"));
00288     }
00289 
00356     inline Tp::PendingVariant *requestPropertyRequested() const
00357     {
00358         return internalRequestProperty(QLatin1String("Requested"));
00359     }
00360 
00420     inline Tp::PendingVariant *requestPropertyInitiatorHandle() const
00421     {
00422         return internalRequestProperty(QLatin1String("InitiatorHandle"));
00423     }
00424 
00457     inline Tp::PendingVariant *requestPropertyInitiatorID() const
00458     {
00459         return internalRequestProperty(QLatin1String("InitiatorID"));
00460     }
00461 
00468     Tp::PendingVariantMap *requestAllProperties() const
00469     {
00470         return internalRequestAllProperties();
00471     }
00472 
00473 public Q_SLOTS:
00488     inline QDBusPendingReply<> Close(int timeout = -1)
00489     {
00490         if (!invalidationReason().isEmpty()) {
00491             return QDBusPendingReply<>(QDBusMessage::createError(
00492                 invalidationReason(),
00493                 invalidationMessage()
00494             ));
00495         }
00496 
00497         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00498                 this->staticInterfaceName(), QLatin1String("Close"));
00499         return this->connection().asyncCall(callMessage, timeout);
00500     }
00501 
00519     inline QDBusPendingReply<QString> GetChannelType(int timeout = -1)
00520     {
00521         if (!invalidationReason().isEmpty()) {
00522             return QDBusPendingReply<QString>(QDBusMessage::createError(
00523                 invalidationReason(),
00524                 invalidationMessage()
00525             ));
00526         }
00527 
00528         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00529                 this->staticInterfaceName(), QLatin1String("GetChannelType"));
00530         return this->connection().asyncCall(callMessage, timeout);
00531     }
00532 
00556     inline QDBusPendingReply<uint, uint> GetHandle(int timeout = -1)
00557     {
00558         if (!invalidationReason().isEmpty()) {
00559             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00560                 invalidationReason(),
00561                 invalidationMessage()
00562             ));
00563         }
00564 
00565         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00566                 this->staticInterfaceName(), QLatin1String("GetHandle"));
00567         return this->connection().asyncCall(callMessage, timeout);
00568     }
00569 
00587     inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00588     {
00589         if (!invalidationReason().isEmpty()) {
00590             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00591                 invalidationReason(),
00592                 invalidationMessage()
00593             ));
00594         }
00595 
00596         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00597                 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00598         return this->connection().asyncCall(callMessage, timeout);
00599     }
00600 
00601 Q_SIGNALS:
00609     void Closed();
00610 
00611 protected:
00612     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00613 };
00614 
00622 class TELEPATHY_QT4_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
00623 {
00624     Q_OBJECT
00625 
00626 public:
00633     static inline QLatin1String staticInterfaceName()
00634     {
00635         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Anonymity");
00636     }
00637 
00645     ChannelInterfaceAnonymityInterface(
00646         const QString& busName,
00647         const QString& objectPath,
00648         QObject* parent = 0
00649     );
00650 
00659     ChannelInterfaceAnonymityInterface(
00660         const QDBusConnection& connection,
00661         const QString& busName,
00662         const QString& objectPath,
00663         QObject* parent = 0
00664     );
00665 
00672     ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00673 
00681     explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);
00682 
00690     ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00691 
00702     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
00703     {
00704         return internalRequestProperty(QLatin1String("AnonymityModes"));
00705     }
00706 
00717     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
00718     {
00719         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
00720     }
00721 
00741     inline Tp::PendingVariant *requestPropertyAnonymousID() const
00742     {
00743         return internalRequestProperty(QLatin1String("AnonymousID"));
00744     }
00745 
00752     Tp::PendingVariantMap *requestAllProperties() const
00753     {
00754         return internalRequestAllProperties();
00755     }
00756 
00757 protected:
00758     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00759 };
00760 
00768 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00769 {
00770     Q_OBJECT
00771 
00772 public:
00779     static inline QLatin1String staticInterfaceName()
00780     {
00781         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.CallState");
00782     }
00783 
00791     ChannelInterfaceCallStateInterface(
00792         const QString& busName,
00793         const QString& objectPath,
00794         QObject* parent = 0
00795     );
00796 
00805     ChannelInterfaceCallStateInterface(
00806         const QDBusConnection& connection,
00807         const QString& busName,
00808         const QString& objectPath,
00809         QObject* parent = 0
00810     );
00811 
00818     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00819 
00827     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00828 
00836     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00837 
00844     Tp::PendingVariantMap *requestAllProperties() const
00845     {
00846         return internalRequestAllProperties();
00847     }
00848 
00849 public Q_SLOTS:
00865     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates(int timeout = -1)
00866     {
00867         if (!invalidationReason().isEmpty()) {
00868             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00869                 invalidationReason(),
00870                 invalidationMessage()
00871             ));
00872         }
00873 
00874         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00875                 this->staticInterfaceName(), QLatin1String("GetCallStates"));
00876         return this->connection().asyncCall(callMessage, timeout);
00877     }
00878 
00879 Q_SIGNALS:
00893     void CallStateChanged(uint contact, uint state);
00894 
00895 protected:
00896     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00897 };
00898 
00906 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00907 {
00908     Q_OBJECT
00909 
00910 public:
00917     static inline QLatin1String staticInterfaceName()
00918     {
00919         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ChatState");
00920     }
00921 
00929     ChannelInterfaceChatStateInterface(
00930         const QString& busName,
00931         const QString& objectPath,
00932         QObject* parent = 0
00933     );
00934 
00943     ChannelInterfaceChatStateInterface(
00944         const QDBusConnection& connection,
00945         const QString& busName,
00946         const QString& objectPath,
00947         QObject* parent = 0
00948     );
00949 
00956     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00957 
00965     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00966 
00974     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00975 
01009     inline Tp::PendingVariant *requestPropertyChatStates() const
01010     {
01011         return internalRequestProperty(QLatin1String("ChatStates"));
01012     }
01013 
01020     Tp::PendingVariantMap *requestAllProperties() const
01021     {
01022         return internalRequestAllProperties();
01023     }
01024 
01025 public Q_SLOTS:
01041     inline QDBusPendingReply<> SetChatState(uint state, int timeout = -1)
01042     {
01043         if (!invalidationReason().isEmpty()) {
01044             return QDBusPendingReply<>(QDBusMessage::createError(
01045                 invalidationReason(),
01046                 invalidationMessage()
01047             ));
01048         }
01049 
01050         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01051                 this->staticInterfaceName(), QLatin1String("SetChatState"));
01052         callMessage << QVariant::fromValue(state);
01053         return this->connection().asyncCall(callMessage, timeout);
01054     }
01055 
01056 Q_SIGNALS:
01071     void ChatStateChanged(uint contact, uint state);
01072 
01073 protected:
01074     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01075 };
01076 
01084 class TELEPATHY_QT4_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
01085 {
01086     Q_OBJECT
01087 
01088 public:
01095     static inline QLatin1String staticInterfaceName()
01096     {
01097         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Conference");
01098     }
01099 
01107     ChannelInterfaceConferenceInterface(
01108         const QString& busName,
01109         const QString& objectPath,
01110         QObject* parent = 0
01111     );
01112 
01121     ChannelInterfaceConferenceInterface(
01122         const QDBusConnection& connection,
01123         const QString& busName,
01124         const QString& objectPath,
01125         QObject* parent = 0
01126     );
01127 
01134     ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
01135 
01143     explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
01144 
01152     ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01153 
01180     inline Tp::PendingVariant *requestPropertyChannels() const
01181     {
01182         return internalRequestProperty(QLatin1String("Channels"));
01183     }
01184 
01246     inline Tp::PendingVariant *requestPropertyInitialChannels() const
01247     {
01248         return internalRequestProperty(QLatin1String("InitialChannels"));
01249     }
01250 
01324     inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
01325     {
01326         return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
01327     }
01328 
01353     inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
01354     {
01355         return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
01356     }
01357 
01385     inline Tp::PendingVariant *requestPropertyInvitationMessage() const
01386     {
01387         return internalRequestProperty(QLatin1String("InvitationMessage"));
01388     }
01389 
01453     inline Tp::PendingVariant *requestPropertyOriginalChannels() const
01454     {
01455         return internalRequestProperty(QLatin1String("OriginalChannels"));
01456     }
01457 
01464     Tp::PendingVariantMap *requestAllProperties() const
01465     {
01466         return internalRequestAllProperties();
01467     }
01468 
01469 Q_SIGNALS:
01491     void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01492 
01513     void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01514 
01515 protected:
01516     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01517 };
01518 
01526 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01527 {
01528     Q_OBJECT
01529 
01530 public:
01537     static inline QLatin1String staticInterfaceName()
01538     {
01539         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
01540     }
01541 
01549     ChannelInterfaceDTMFInterface(
01550         const QString& busName,
01551         const QString& objectPath,
01552         QObject* parent = 0
01553     );
01554 
01563     ChannelInterfaceDTMFInterface(
01564         const QDBusConnection& connection,
01565         const QString& busName,
01566         const QString& objectPath,
01567         QObject* parent = 0
01568     );
01569 
01576     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
01577 
01585     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
01586 
01594     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01595 
01607     inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
01608     {
01609         return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
01610     }
01611 
01624     inline Tp::PendingVariant *requestPropertyInitialTones() const
01625     {
01626         return internalRequestProperty(QLatin1String("InitialTones"));
01627     }
01628 
01635     Tp::PendingVariantMap *requestAllProperties() const
01636     {
01637         return internalRequestAllProperties();
01638     }
01639 
01640 public Q_SLOTS:
01671     inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
01672     {
01673         if (!invalidationReason().isEmpty()) {
01674             return QDBusPendingReply<>(QDBusMessage::createError(
01675                 invalidationReason(),
01676                 invalidationMessage()
01677             ));
01678         }
01679 
01680         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01681                 this->staticInterfaceName(), QLatin1String("StartTone"));
01682         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01683         return this->connection().asyncCall(callMessage, timeout);
01684     }
01685 
01708     inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
01709     {
01710         if (!invalidationReason().isEmpty()) {
01711             return QDBusPendingReply<>(QDBusMessage::createError(
01712                 invalidationReason(),
01713                 invalidationMessage()
01714             ));
01715         }
01716 
01717         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01718                 this->staticInterfaceName(), QLatin1String("StopTone"));
01719         callMessage << QVariant::fromValue(streamID);
01720         return this->connection().asyncCall(callMessage, timeout);
01721     }
01722 
01746     inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
01747     {
01748         if (!invalidationReason().isEmpty()) {
01749             return QDBusPendingReply<>(QDBusMessage::createError(
01750                 invalidationReason(),
01751                 invalidationMessage()
01752             ));
01753         }
01754 
01755         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01756                 this->staticInterfaceName(), QLatin1String("MultipleTones"));
01757         callMessage << QVariant::fromValue(tones);
01758         return this->connection().asyncCall(callMessage, timeout);
01759     }
01760 
01761 Q_SIGNALS:
01776     void SendingTones(const QString& tones);
01777 
01787     void StoppedTones(bool cancelled);
01788 
01789 protected:
01790     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01791 };
01792 
01800 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
01801 {
01802     Q_OBJECT
01803 
01804 public:
01811     static inline QLatin1String staticInterfaceName()
01812     {
01813         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
01814     }
01815 
01823     ChannelInterfaceGroupInterface(
01824         const QString& busName,
01825         const QString& objectPath,
01826         QObject* parent = 0
01827     );
01828 
01837     ChannelInterfaceGroupInterface(
01838         const QDBusConnection& connection,
01839         const QString& busName,
01840         const QString& objectPath,
01841         QObject* parent = 0
01842     );
01843 
01850     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01851 
01859     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01860 
01868     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01869 
01882     inline Tp::PendingVariant *requestPropertyGroupFlags() const
01883     {
01884         return internalRequestProperty(QLatin1String("GroupFlags"));
01885     }
01886 
01902     inline Tp::PendingVariant *requestPropertyHandleOwners() const
01903     {
01904         return internalRequestProperty(QLatin1String("HandleOwners"));
01905     }
01906 
01917     inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
01918     {
01919         return internalRequestProperty(QLatin1String("LocalPendingMembers"));
01920     }
01921 
01931     inline Tp::PendingVariant *requestPropertyMembers() const
01932     {
01933         return internalRequestProperty(QLatin1String("Members"));
01934     }
01935 
01946     inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
01947     {
01948         return internalRequestProperty(QLatin1String("RemotePendingMembers"));
01949     }
01950 
01965     inline Tp::PendingVariant *requestPropertySelfHandle() const
01966     {
01967         return internalRequestProperty(QLatin1String("SelfHandle"));
01968     }
01969 
01976     Tp::PendingVariantMap *requestAllProperties() const
01977     {
01978         return internalRequestAllProperties();
01979     }
01980 
01981 public Q_SLOTS:
02010     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02011     {
02012         if (!invalidationReason().isEmpty()) {
02013             return QDBusPendingReply<>(QDBusMessage::createError(
02014                 invalidationReason(),
02015                 invalidationMessage()
02016             ));
02017         }
02018 
02019         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02020                 this->staticInterfaceName(), QLatin1String("AddMembers"));
02021         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02022         return this->connection().asyncCall(callMessage, timeout);
02023     }
02024 
02047     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
02048     {
02049         if (!invalidationReason().isEmpty()) {
02050             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02051                 invalidationReason(),
02052                 invalidationMessage()
02053             ));
02054         }
02055 
02056         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02057                 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
02058         return this->connection().asyncCall(callMessage, timeout);
02059     }
02060 
02075     inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
02076     {
02077         if (!invalidationReason().isEmpty()) {
02078             return QDBusPendingReply<uint>(QDBusMessage::createError(
02079                 invalidationReason(),
02080                 invalidationMessage()
02081             ));
02082         }
02083 
02084         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02085                 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
02086         return this->connection().asyncCall(callMessage, timeout);
02087     }
02088 
02114     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
02115     {
02116         if (!invalidationReason().isEmpty()) {
02117             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02118                 invalidationReason(),
02119                 invalidationMessage()
02120             ));
02121         }
02122 
02123         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02124                 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
02125         callMessage << QVariant::fromValue(handles);
02126         return this->connection().asyncCall(callMessage, timeout);
02127     }
02128 
02140     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
02141     {
02142         if (!invalidationReason().isEmpty()) {
02143             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02144                 invalidationReason(),
02145                 invalidationMessage()
02146             ));
02147         }
02148 
02149         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02150                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
02151         return this->connection().asyncCall(callMessage, timeout);
02152     }
02153 
02172     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
02173     {
02174         if (!invalidationReason().isEmpty()) {
02175             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
02176                 invalidationReason(),
02177                 invalidationMessage()
02178             ));
02179         }
02180 
02181         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02182                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
02183         return this->connection().asyncCall(callMessage, timeout);
02184     }
02185 
02196     inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
02197     {
02198         if (!invalidationReason().isEmpty()) {
02199             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02200                 invalidationReason(),
02201                 invalidationMessage()
02202             ));
02203         }
02204 
02205         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02206                 this->staticInterfaceName(), QLatin1String("GetMembers"));
02207         return this->connection().asyncCall(callMessage, timeout);
02208     }
02209 
02221     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
02222     {
02223         if (!invalidationReason().isEmpty()) {
02224             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02225                 invalidationReason(),
02226                 invalidationMessage()
02227             ));
02228         }
02229 
02230         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02231                 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
02232         return this->connection().asyncCall(callMessage, timeout);
02233     }
02234 
02245     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
02246     {
02247         if (!invalidationReason().isEmpty()) {
02248             return QDBusPendingReply<uint>(QDBusMessage::createError(
02249                 invalidationReason(),
02250                 invalidationMessage()
02251             ));
02252         }
02253 
02254         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02255                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
02256         return this->connection().asyncCall(callMessage, timeout);
02257     }
02258 
02312     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02313     {
02314         if (!invalidationReason().isEmpty()) {
02315             return QDBusPendingReply<>(QDBusMessage::createError(
02316                 invalidationReason(),
02317                 invalidationMessage()
02318             ));
02319         }
02320 
02321         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02322                 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
02323         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02324         return this->connection().asyncCall(callMessage, timeout);
02325     }
02326 
02351     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
02352     {
02353         if (!invalidationReason().isEmpty()) {
02354             return QDBusPendingReply<>(QDBusMessage::createError(
02355                 invalidationReason(),
02356                 invalidationMessage()
02357             ));
02358         }
02359 
02360         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02361                 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
02362         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
02363         return this->connection().asyncCall(callMessage, timeout);
02364     }
02365 
02366 Q_SIGNALS:
02385     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
02386 
02396     void SelfHandleChanged(uint selfHandle);
02397 
02412     void GroupFlagsChanged(uint added, uint removed);
02413 
02465     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);
02466 
02571     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
02572 
02573 protected:
02574     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02575 };
02576 
02584 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
02585 {
02586     Q_OBJECT
02587 
02588 public:
02595     static inline QLatin1String staticInterfaceName()
02596     {
02597         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
02598     }
02599 
02607     ChannelInterfaceHoldInterface(
02608         const QString& busName,
02609         const QString& objectPath,
02610         QObject* parent = 0
02611     );
02612 
02621     ChannelInterfaceHoldInterface(
02622         const QDBusConnection& connection,
02623         const QString& busName,
02624         const QString& objectPath,
02625         QObject* parent = 0
02626     );
02627 
02634     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
02635 
02643     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
02644 
02652     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02653 
02660     Tp::PendingVariantMap *requestAllProperties() const
02661     {
02662         return internalRequestAllProperties();
02663     }
02664 
02665 public Q_SLOTS:
02684     inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
02685     {
02686         if (!invalidationReason().isEmpty()) {
02687             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
02688                 invalidationReason(),
02689                 invalidationMessage()
02690             ));
02691         }
02692 
02693         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02694                 this->staticInterfaceName(), QLatin1String("GetHoldState"));
02695         return this->connection().asyncCall(callMessage, timeout);
02696     }
02697 
02759     inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
02760     {
02761         if (!invalidationReason().isEmpty()) {
02762             return QDBusPendingReply<>(QDBusMessage::createError(
02763                 invalidationReason(),
02764                 invalidationMessage()
02765             ));
02766         }
02767 
02768         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02769                 this->staticInterfaceName(), QLatin1String("RequestHold"));
02770         callMessage << QVariant::fromValue(hold);
02771         return this->connection().asyncCall(callMessage, timeout);
02772     }
02773 
02774 Q_SIGNALS:
02791     void HoldStateChanged(uint holdState, uint reason);
02792 
02793 protected:
02794     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02795 };
02796 
02804 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
02805 {
02806     Q_OBJECT
02807 
02808 public:
02815     static inline QLatin1String staticInterfaceName()
02816     {
02817         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
02818     }
02819 
02827     ChannelInterfaceMediaSignallingInterface(
02828         const QString& busName,
02829         const QString& objectPath,
02830         QObject* parent = 0
02831     );
02832 
02841     ChannelInterfaceMediaSignallingInterface(
02842         const QDBusConnection& connection,
02843         const QString& busName,
02844         const QString& objectPath,
02845         QObject* parent = 0
02846     );
02847 
02854     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
02855 
02863     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
02864 
02872     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02873 
02880     Tp::PendingVariantMap *requestAllProperties() const
02881     {
02882         return internalRequestAllProperties();
02883     }
02884 
02885 public Q_SLOTS:
02897     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
02898     {
02899         if (!invalidationReason().isEmpty()) {
02900             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02901                 invalidationReason(),
02902                 invalidationMessage()
02903             ));
02904         }
02905 
02906         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02907                 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
02908         return this->connection().asyncCall(callMessage, timeout);
02909     }
02910 
02911 Q_SIGNALS:
02927     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02928 
02929 protected:
02930     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02931 };
02932 
02940 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
02941 {
02942     Q_OBJECT
02943 
02944 public:
02951     static inline QLatin1String staticInterfaceName()
02952     {
02953         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
02954     }
02955 
02963     ChannelInterfaceMessagesInterface(
02964         const QString& busName,
02965         const QString& objectPath,
02966         QObject* parent = 0
02967     );
02968 
02977     ChannelInterfaceMessagesInterface(
02978         const QDBusConnection& connection,
02979         const QString& busName,
02980         const QString& objectPath,
02981         QObject* parent = 0
02982     );
02983 
02990     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
02991 
02999     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
03000 
03008     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03009 
03059     inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
03060     {
03061         return internalRequestProperty(QLatin1String("SupportedContentTypes"));
03062     }
03063 
03073     inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
03074     {
03075         return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
03076     }
03077 
03091     inline Tp::PendingVariant *requestPropertyPendingMessages() const
03092     {
03093         return internalRequestProperty(QLatin1String("PendingMessages"));
03094     }
03095 
03105     inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
03106     {
03107         return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
03108     }
03109 
03116     Tp::PendingVariantMap *requestAllProperties() const
03117     {
03118         return internalRequestAllProperties();
03119     }
03120 
03121 public Q_SLOTS:
03168     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
03169     {
03170         if (!invalidationReason().isEmpty()) {
03171             return QDBusPendingReply<QString>(QDBusMessage::createError(
03172                 invalidationReason(),
03173                 invalidationMessage()
03174             ));
03175         }
03176 
03177         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03178                 this->staticInterfaceName(), QLatin1String("SendMessage"));
03179         callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
03180         return this->connection().asyncCall(callMessage, timeout);
03181     }
03182 
03221     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
03222     {
03223         if (!invalidationReason().isEmpty()) {
03224             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
03225                 invalidationReason(),
03226                 invalidationMessage()
03227             ));
03228         }
03229 
03230         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03231                 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
03232         callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
03233         return this->connection().asyncCall(callMessage, timeout);
03234     }
03235 
03236 Q_SIGNALS:
03284     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
03285 
03299     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
03300 
03319     void MessageReceived(const Tp::MessagePartList& message);
03320 
03321 protected:
03322     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03323 };
03324 
03332 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
03333 {
03334     Q_OBJECT
03335 
03336 public:
03343     static inline QLatin1String staticInterfaceName()
03344     {
03345         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
03346     }
03347 
03355     ChannelInterfacePasswordInterface(
03356         const QString& busName,
03357         const QString& objectPath,
03358         QObject* parent = 0
03359     );
03360 
03369     ChannelInterfacePasswordInterface(
03370         const QDBusConnection& connection,
03371         const QString& busName,
03372         const QString& objectPath,
03373         QObject* parent = 0
03374     );
03375 
03382     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
03383 
03391     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
03392 
03400     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03401 
03408     Tp::PendingVariantMap *requestAllProperties() const
03409     {
03410         return internalRequestAllProperties();
03411     }
03412 
03413 public Q_SLOTS:
03431     inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
03432     {
03433         if (!invalidationReason().isEmpty()) {
03434             return QDBusPendingReply<uint>(QDBusMessage::createError(
03435                 invalidationReason(),
03436                 invalidationMessage()
03437             ));
03438         }
03439 
03440         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03441                 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
03442         return this->connection().asyncCall(callMessage, timeout);
03443     }
03444 
03465     inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
03466     {
03467         if (!invalidationReason().isEmpty()) {
03468             return QDBusPendingReply<bool>(QDBusMessage::createError(
03469                 invalidationReason(),
03470                 invalidationMessage()
03471             ));
03472         }
03473 
03474         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03475                 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
03476         callMessage << QVariant::fromValue(password);
03477         return this->connection().asyncCall(callMessage, timeout);
03478     }
03479 
03480 Q_SIGNALS:
03495     void PasswordFlagsChanged(uint added, uint removed);
03496 
03497 protected:
03498     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03499 };
03500 
03508 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
03509 {
03510     Q_OBJECT
03511 
03512 public:
03519     static inline QLatin1String staticInterfaceName()
03520     {
03521         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
03522     }
03523 
03531     ChannelInterfaceServicePointInterface(
03532         const QString& busName,
03533         const QString& objectPath,
03534         QObject* parent = 0
03535     );
03536 
03545     ChannelInterfaceServicePointInterface(
03546         const QDBusConnection& connection,
03547         const QString& busName,
03548         const QString& objectPath,
03549         QObject* parent = 0
03550     );
03551 
03558     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
03559 
03567     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
03568 
03576     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03577 
03595     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
03596     {
03597         return internalRequestProperty(QLatin1String("InitialServicePoint"));
03598     }
03599 
03612     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
03613     {
03614         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
03615     }
03616 
03623     Tp::PendingVariantMap *requestAllProperties() const
03624     {
03625         return internalRequestAllProperties();
03626     }
03627 
03628 Q_SIGNALS:
03645     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
03646 
03647 protected:
03648     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03649 };
03650 
03658 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
03659 {
03660     Q_OBJECT
03661 
03662 public:
03669     static inline QLatin1String staticInterfaceName()
03670     {
03671         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
03672     }
03673 
03681     ChannelInterfaceTubeInterface(
03682         const QString& busName,
03683         const QString& objectPath,
03684         QObject* parent = 0
03685     );
03686 
03695     ChannelInterfaceTubeInterface(
03696         const QDBusConnection& connection,
03697         const QString& busName,
03698         const QString& objectPath,
03699         QObject* parent = 0
03700     );
03701 
03708     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
03709 
03717     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
03718 
03726     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03727 
03771     inline Tp::PendingVariant *requestPropertyParameters() const
03772     {
03773         return internalRequestProperty(QLatin1String("Parameters"));
03774     }
03775 
03789     inline Tp::PendingVariant *requestPropertyState() const
03790     {
03791         return internalRequestProperty(QLatin1String("State"));
03792     }
03793 
03800     Tp::PendingVariantMap *requestAllProperties() const
03801     {
03802         return internalRequestAllProperties();
03803     }
03804 
03805 Q_SIGNALS:
03816     void TubeChannelStateChanged(uint state);
03817 
03818 protected:
03819     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03820 };
03821 
03829 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
03830 {
03831     Q_OBJECT
03832 
03833 public:
03840     static inline QLatin1String staticInterfaceName()
03841     {
03842         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
03843     }
03844 
03852     ChannelTypeContactListInterface(
03853         const QString& busName,
03854         const QString& objectPath,
03855         QObject* parent = 0
03856     );
03857 
03866     ChannelTypeContactListInterface(
03867         const QDBusConnection& connection,
03868         const QString& busName,
03869         const QString& objectPath,
03870         QObject* parent = 0
03871     );
03872 
03879     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
03880 
03888     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
03889 
03897     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03898 
03905     Tp::PendingVariantMap *requestAllProperties() const
03906     {
03907         return internalRequestAllProperties();
03908     }
03909 
03910 protected:
03911     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03912 };
03913 
03921 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
03922 {
03923     Q_OBJECT
03924 
03925 public:
03932     static inline QLatin1String staticInterfaceName()
03933     {
03934         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
03935     }
03936 
03944     ChannelTypeContactSearchInterface(
03945         const QString& busName,
03946         const QString& objectPath,
03947         QObject* parent = 0
03948     );
03949 
03958     ChannelTypeContactSearchInterface(
03959         const QDBusConnection& connection,
03960         const QString& busName,
03961         const QString& objectPath,
03962         QObject* parent = 0
03963     );
03964 
03971     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
03972 
03980     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
03981 
03989     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03990 
04001     inline Tp::PendingVariant *requestPropertySearchState() const
04002     {
04003         return internalRequestProperty(QLatin1String("SearchState"));
04004     }
04005 
04031     inline Tp::PendingVariant *requestPropertyLimit() const
04032     {
04033         return internalRequestProperty(QLatin1String("Limit"));
04034     }
04035 
04051     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
04052     {
04053         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
04054     }
04055 
04077     inline Tp::PendingVariant *requestPropertyServer() const
04078     {
04079         return internalRequestProperty(QLatin1String("Server"));
04080     }
04081 
04088     Tp::PendingVariantMap *requestAllProperties() const
04089     {
04090         return internalRequestAllProperties();
04091     }
04092 
04093 public Q_SLOTS:
04111     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
04112     {
04113         if (!invalidationReason().isEmpty()) {
04114             return QDBusPendingReply<>(QDBusMessage::createError(
04115                 invalidationReason(),
04116                 invalidationMessage()
04117             ));
04118         }
04119 
04120         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04121                 this->staticInterfaceName(), QLatin1String("Search"));
04122         callMessage << QVariant::fromValue(terms);
04123         return this->connection().asyncCall(callMessage, timeout);
04124     }
04125 
04138     inline QDBusPendingReply<> More(int timeout = -1)
04139     {
04140         if (!invalidationReason().isEmpty()) {
04141             return QDBusPendingReply<>(QDBusMessage::createError(
04142                 invalidationReason(),
04143                 invalidationMessage()
04144             ));
04145         }
04146 
04147         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04148                 this->staticInterfaceName(), QLatin1String("More"));
04149         return this->connection().asyncCall(callMessage, timeout);
04150     }
04151 
04182     inline QDBusPendingReply<> Stop(int timeout = -1)
04183     {
04184         if (!invalidationReason().isEmpty()) {
04185             return QDBusPendingReply<>(QDBusMessage::createError(
04186                 invalidationReason(),
04187                 invalidationMessage()
04188             ));
04189         }
04190 
04191         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04192                 this->staticInterfaceName(), QLatin1String("Stop"));
04193         return this->connection().asyncCall(callMessage, timeout);
04194     }
04195 
04196 Q_SIGNALS:
04240     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
04241 
04254     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
04255 
04256 protected:
04257     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04258 };
04259 
04267 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
04268 {
04269     Q_OBJECT
04270 
04271 public:
04278     static inline QLatin1String staticInterfaceName()
04279     {
04280         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
04281     }
04282 
04290     ChannelTypeFileTransferInterface(
04291         const QString& busName,
04292         const QString& objectPath,
04293         QObject* parent = 0
04294     );
04295 
04304     ChannelTypeFileTransferInterface(
04305         const QDBusConnection& connection,
04306         const QString& busName,
04307         const QString& objectPath,
04308         QObject* parent = 0
04309     );
04310 
04317     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
04318 
04326     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
04327 
04335     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04336 
04347     inline Tp::PendingVariant *requestPropertyState() const
04348     {
04349         return internalRequestProperty(QLatin1String("State"));
04350     }
04351 
04367     inline Tp::PendingVariant *requestPropertyContentType() const
04368     {
04369         return internalRequestProperty(QLatin1String("ContentType"));
04370     }
04371 
04391     inline Tp::PendingVariant *requestPropertyFilename() const
04392     {
04393         return internalRequestProperty(QLatin1String("Filename"));
04394     }
04395 
04417     inline Tp::PendingVariant *requestPropertySize() const
04418     {
04419         return internalRequestProperty(QLatin1String("Size"));
04420     }
04421 
04446     inline Tp::PendingVariant *requestPropertyContentHashType() const
04447     {
04448         return internalRequestProperty(QLatin1String("ContentHashType"));
04449     }
04450 
04469     inline Tp::PendingVariant *requestPropertyContentHash() const
04470     {
04471         return internalRequestProperty(QLatin1String("ContentHash"));
04472     }
04473 
04489     inline Tp::PendingVariant *requestPropertyDescription() const
04490     {
04491         return internalRequestProperty(QLatin1String("Description"));
04492     }
04493 
04508     inline Tp::PendingVariant *requestPropertyDate() const
04509     {
04510         return internalRequestProperty(QLatin1String("Date"));
04511     }
04512 
04539     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
04540     {
04541         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
04542     }
04543 
04555     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
04556     {
04557         return internalRequestProperty(QLatin1String("TransferredBytes"));
04558     }
04559 
04580     inline Tp::PendingVariant *requestPropertyInitialOffset() const
04581     {
04582         return internalRequestProperty(QLatin1String("InitialOffset"));
04583     }
04584 
04591     Tp::PendingVariantMap *requestAllProperties() const
04592     {
04593         return internalRequestAllProperties();
04594     }
04595 
04596 public Q_SLOTS:
04641     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
04642     {
04643         if (!invalidationReason().isEmpty()) {
04644             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04645                 invalidationReason(),
04646                 invalidationMessage()
04647             ));
04648         }
04649 
04650         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04651                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
04652         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
04653         return this->connection().asyncCall(callMessage, timeout);
04654     }
04655 
04689     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
04690     {
04691         if (!invalidationReason().isEmpty()) {
04692             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04693                 invalidationReason(),
04694                 invalidationMessage()
04695             ));
04696         }
04697 
04698         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04699                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
04700         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
04701         return this->connection().asyncCall(callMessage, timeout);
04702     }
04703 
04704 Q_SIGNALS:
04722     void FileTransferStateChanged(uint state, uint reason);
04723 
04736     void TransferredBytesChanged(qulonglong count);
04737 
04749     void InitialOffsetDefined(qulonglong initialOffset);
04750 
04751 protected:
04752     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04753 };
04754 
04762 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
04763 {
04764     Q_OBJECT
04765 
04766 public:
04773     static inline QLatin1String staticInterfaceName()
04774     {
04775         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
04776     }
04777 
04785     ChannelTypeRoomListInterface(
04786         const QString& busName,
04787         const QString& objectPath,
04788         QObject* parent = 0
04789     );
04790 
04799     ChannelTypeRoomListInterface(
04800         const QDBusConnection& connection,
04801         const QString& busName,
04802         const QString& objectPath,
04803         QObject* parent = 0
04804     );
04805 
04812     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
04813 
04821     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
04822 
04830     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04831 
04845     inline Tp::PendingVariant *requestPropertyServer() const
04846     {
04847         return internalRequestProperty(QLatin1String("Server"));
04848     }
04849 
04856     Tp::PendingVariantMap *requestAllProperties() const
04857     {
04858         return internalRequestAllProperties();
04859     }
04860 
04861 public Q_SLOTS:
04877     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
04878     {
04879         if (!invalidationReason().isEmpty()) {
04880             return QDBusPendingReply<bool>(QDBusMessage::createError(
04881                 invalidationReason(),
04882                 invalidationMessage()
04883             ));
04884         }
04885 
04886         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04887                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
04888         return this->connection().asyncCall(callMessage, timeout);
04889     }
04890 
04904     inline QDBusPendingReply<> ListRooms(int timeout = -1)
04905     {
04906         if (!invalidationReason().isEmpty()) {
04907             return QDBusPendingReply<>(QDBusMessage::createError(
04908                 invalidationReason(),
04909                 invalidationMessage()
04910             ));
04911         }
04912 
04913         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04914                 this->staticInterfaceName(), QLatin1String("ListRooms"));
04915         return this->connection().asyncCall(callMessage, timeout);
04916     }
04917 
04930     inline QDBusPendingReply<> StopListing(int timeout = -1)
04931     {
04932         if (!invalidationReason().isEmpty()) {
04933             return QDBusPendingReply<>(QDBusMessage::createError(
04934                 invalidationReason(),
04935                 invalidationMessage()
04936             ));
04937         }
04938 
04939         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04940                 this->staticInterfaceName(), QLatin1String("StopListing"));
04941         return this->connection().asyncCall(callMessage, timeout);
04942     }
04943 
04944 Q_SIGNALS:
04998     void GotRooms(const Tp::RoomInfoList& rooms);
04999 
05010     void ListingRooms(bool listing);
05011 
05012 protected:
05013     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05014 };
05015 
05023 class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
05024 {
05025     Q_OBJECT
05026 
05027 public:
05034     static inline QLatin1String staticInterfaceName()
05035     {
05036         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
05037     }
05038 
05046     ChannelTypeServerTLSConnectionInterface(
05047         const QString& busName,
05048         const QString& objectPath,
05049         QObject* parent = 0
05050     );
05051 
05060     ChannelTypeServerTLSConnectionInterface(
05061         const QDBusConnection& connection,
05062         const QString& busName,
05063         const QString& objectPath,
05064         QObject* parent = 0
05065     );
05066 
05073     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
05074 
05082     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
05083 
05091     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05092 
05103     inline Tp::PendingVariant *requestPropertyServerCertificate() const
05104     {
05105         return internalRequestProperty(QLatin1String("ServerCertificate"));
05106     }
05107 
05119     inline Tp::PendingVariant *requestPropertyHostname() const
05120     {
05121         return internalRequestProperty(QLatin1String("Hostname"));
05122     }
05123 
05130     Tp::PendingVariantMap *requestAllProperties() const
05131     {
05132         return internalRequestAllProperties();
05133     }
05134 
05135 protected:
05136     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05137 };
05138 
05146 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
05147 {
05148     Q_OBJECT
05149 
05150 public:
05157     static inline QLatin1String staticInterfaceName()
05158     {
05159         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
05160     }
05161 
05169     ChannelTypeStreamTubeInterface(
05170         const QString& busName,
05171         const QString& objectPath,
05172         QObject* parent = 0
05173     );
05174 
05183     ChannelTypeStreamTubeInterface(
05184         const QDBusConnection& connection,
05185         const QString& busName,
05186         const QString& objectPath,
05187         QObject* parent = 0
05188     );
05189 
05196     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
05197 
05205     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
05206 
05214     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05215 
05236     inline Tp::PendingVariant *requestPropertyService() const
05237     {
05238         return internalRequestProperty(QLatin1String("Service"));
05239     }
05240 
05273     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
05274     {
05275         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
05276     }
05277 
05284     Tp::PendingVariantMap *requestAllProperties() const
05285     {
05286         return internalRequestAllProperties();
05287     }
05288 
05289 public Q_SLOTS:
05320     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
05321     {
05322         if (!invalidationReason().isEmpty()) {
05323             return QDBusPendingReply<>(QDBusMessage::createError(
05324                 invalidationReason(),
05325                 invalidationMessage()
05326             ));
05327         }
05328 
05329         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05330                 this->staticInterfaceName(), QLatin1String("Offer"));
05331         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
05332         return this->connection().asyncCall(callMessage, timeout);
05333     }
05334 
05373     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
05374     {
05375         if (!invalidationReason().isEmpty()) {
05376             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05377                 invalidationReason(),
05378                 invalidationMessage()
05379             ));
05380         }
05381 
05382         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05383                 this->staticInterfaceName(), QLatin1String("Accept"));
05384         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
05385         return this->connection().asyncCall(callMessage, timeout);
05386     }
05387 
05388 Q_SIGNALS:
05425     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
05426 
05440     void NewLocalConnection(uint connectionID);
05441 
05469     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
05470 
05471 protected:
05472     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05473 };
05474 
05482 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
05483 {
05484     Q_OBJECT
05485 
05486 public:
05493     static inline QLatin1String staticInterfaceName()
05494     {
05495         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
05496     }
05497 
05505     ChannelTypeStreamedMediaInterface(
05506         const QString& busName,
05507         const QString& objectPath,
05508         QObject* parent = 0
05509     );
05510 
05519     ChannelTypeStreamedMediaInterface(
05520         const QDBusConnection& connection,
05521         const QString& busName,
05522         const QString& objectPath,
05523         QObject* parent = 0
05524     );
05525 
05532     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
05533 
05541     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
05542 
05550     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05551 
05638     inline Tp::PendingVariant *requestPropertyInitialAudio() const
05639     {
05640         return internalRequestProperty(QLatin1String("InitialAudio"));
05641     }
05642 
05661     inline Tp::PendingVariant *requestPropertyInitialVideo() const
05662     {
05663         return internalRequestProperty(QLatin1String("InitialVideo"));
05664     }
05665 
05706     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
05707     {
05708         return internalRequestProperty(QLatin1String("ImmutableStreams"));
05709     }
05710 
05717     Tp::PendingVariantMap *requestAllProperties() const
05718     {
05719         return internalRequestAllProperties();
05720     }
05721 
05722 public Q_SLOTS:
05748     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
05749     {
05750         if (!invalidationReason().isEmpty()) {
05751             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
05752                 invalidationReason(),
05753                 invalidationMessage()
05754             ));
05755         }
05756 
05757         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05758                 this->staticInterfaceName(), QLatin1String("ListStreams"));
05759         return this->connection().asyncCall(callMessage, timeout);
05760     }
05761 
05786     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
05787     {
05788         if (!invalidationReason().isEmpty()) {
05789             return QDBusPendingReply<>(QDBusMessage::createError(
05790                 invalidationReason(),
05791                 invalidationMessage()
05792             ));
05793         }
05794 
05795         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05796                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
05797         callMessage << QVariant::fromValue(streams);
05798         return this->connection().asyncCall(callMessage, timeout);
05799     }
05800 
05835     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
05836     {
05837         if (!invalidationReason().isEmpty()) {
05838             return QDBusPendingReply<>(QDBusMessage::createError(
05839                 invalidationReason(),
05840                 invalidationMessage()
05841             ));
05842         }
05843 
05844         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05845                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
05846         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
05847         return this->connection().asyncCall(callMessage, timeout);
05848     }
05849 
05898     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
05899     {
05900         if (!invalidationReason().isEmpty()) {
05901             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
05902                 invalidationReason(),
05903                 invalidationMessage()
05904             ));
05905         }
05906 
05907         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05908                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
05909         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
05910         return this->connection().asyncCall(callMessage, timeout);
05911     }
05912 
05913 Q_SIGNALS:
05978     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
05979 
06009     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
06010 
06028     void StreamError(uint streamID, uint errorCode, const QString& message);
06029 
06039     void StreamRemoved(uint streamID);
06040 
06054     void StreamStateChanged(uint streamID, uint streamState);
06055 
06056 protected:
06057     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06058 };
06059 
06067 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
06068 {
06069     Q_OBJECT
06070 
06071 public:
06078     static inline QLatin1String staticInterfaceName()
06079     {
06080         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
06081     }
06082 
06090     ChannelTypeTextInterface(
06091         const QString& busName,
06092         const QString& objectPath,
06093         QObject* parent = 0
06094     );
06095 
06104     ChannelTypeTextInterface(
06105         const QDBusConnection& connection,
06106         const QString& busName,
06107         const QString& objectPath,
06108         QObject* parent = 0
06109     );
06110 
06117     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
06118 
06126     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
06127 
06135     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06136 
06143     Tp::PendingVariantMap *requestAllProperties() const
06144     {
06145         return internalRequestAllProperties();
06146     }
06147 
06148 public Q_SLOTS:
06164     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
06165     {
06166         if (!invalidationReason().isEmpty()) {
06167             return QDBusPendingReply<>(QDBusMessage::createError(
06168                 invalidationReason(),
06169                 invalidationMessage()
06170             ));
06171         }
06172 
06173         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06174                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
06175         callMessage << QVariant::fromValue(IDs);
06176         return this->connection().asyncCall(callMessage, timeout);
06177     }
06178 
06194     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
06195     {
06196         if (!invalidationReason().isEmpty()) {
06197             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
06198                 invalidationReason(),
06199                 invalidationMessage()
06200             ));
06201         }
06202 
06203         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06204                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
06205         return this->connection().asyncCall(callMessage, timeout);
06206     }
06207 
06236     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
06237     {
06238         if (!invalidationReason().isEmpty()) {
06239             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
06240                 invalidationReason(),
06241                 invalidationMessage()
06242             ));
06243         }
06244 
06245         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06246                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
06247         callMessage << QVariant::fromValue(clear);
06248         return this->connection().asyncCall(callMessage, timeout);
06249     }
06250 
06281     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
06282     {
06283         if (!invalidationReason().isEmpty()) {
06284             return QDBusPendingReply<>(QDBusMessage::createError(
06285                 invalidationReason(),
06286                 invalidationMessage()
06287             ));
06288         }
06289 
06290         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06291                 this->staticInterfaceName(), QLatin1String("Send"));
06292         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
06293         return this->connection().asyncCall(callMessage, timeout);
06294     }
06295 
06296 Q_SIGNALS:
06304     void LostMessage();
06305 
06339     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
06340 
06367     void SendError(uint error, uint timestamp, uint type, const QString& text);
06368 
06390     void Sent(uint timestamp, uint type, const QString& text);
06391 
06392 protected:
06393     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06394 };
06395 
06403 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
06404 {
06405     Q_OBJECT
06406 
06407 public:
06414     static inline QLatin1String staticInterfaceName()
06415     {
06416         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
06417     }
06418 
06426     ChannelTypeTubesInterface(
06427         const QString& busName,
06428         const QString& objectPath,
06429         QObject* parent = 0
06430     );
06431 
06440     ChannelTypeTubesInterface(
06441         const QDBusConnection& connection,
06442         const QString& busName,
06443         const QString& objectPath,
06444         QObject* parent = 0
06445     );
06446 
06453     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
06454 
06462     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
06463 
06471     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06472 
06479     Tp::PendingVariantMap *requestAllProperties() const
06480     {
06481         return internalRequestAllProperties();
06482     }
06483 
06484 public Q_SLOTS:
06519     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
06520     {
06521         if (!invalidationReason().isEmpty()) {
06522             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
06523                 invalidationReason(),
06524                 invalidationMessage()
06525             ));
06526         }
06527 
06528         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06529                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
06530         return this->connection().asyncCall(callMessage, timeout);
06531     }
06532 
06546     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
06547     {
06548         if (!invalidationReason().isEmpty()) {
06549             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
06550                 invalidationReason(),
06551                 invalidationMessage()
06552             ));
06553         }
06554 
06555         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06556                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
06557         return this->connection().asyncCall(callMessage, timeout);
06558     }
06559 
06575     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
06576     {
06577         if (!invalidationReason().isEmpty()) {
06578             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
06579                 invalidationReason(),
06580                 invalidationMessage()
06581             ));
06582         }
06583 
06584         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06585                 this->staticInterfaceName(), QLatin1String("ListTubes"));
06586         return this->connection().asyncCall(callMessage, timeout);
06587     }
06588 
06616     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
06617     {
06618         if (!invalidationReason().isEmpty()) {
06619             return QDBusPendingReply<uint>(QDBusMessage::createError(
06620                 invalidationReason(),
06621                 invalidationMessage()
06622             ));
06623         }
06624 
06625         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06626                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
06627         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
06628         return this->connection().asyncCall(callMessage, timeout);
06629     }
06630 
06686     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
06687     {
06688         if (!invalidationReason().isEmpty()) {
06689             return QDBusPendingReply<uint>(QDBusMessage::createError(
06690                 invalidationReason(),
06691                 invalidationMessage()
06692             ));
06693         }
06694 
06695         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06696                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
06697         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
06698         return this->connection().asyncCall(callMessage, timeout);
06699     }
06700 
06723     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
06724     {
06725         if (!invalidationReason().isEmpty()) {
06726             return QDBusPendingReply<QString>(QDBusMessage::createError(
06727                 invalidationReason(),
06728                 invalidationMessage()
06729             ));
06730         }
06731 
06732         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06733                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
06734         callMessage << QVariant::fromValue(ID);
06735         return this->connection().asyncCall(callMessage, timeout);
06736     }
06737 
06775     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
06776     {
06777         if (!invalidationReason().isEmpty()) {
06778             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06779                 invalidationReason(),
06780                 invalidationMessage()
06781             ));
06782         }
06783 
06784         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06785                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
06786         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
06787         return this->connection().asyncCall(callMessage, timeout);
06788     }
06789 
06804     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
06805     {
06806         if (!invalidationReason().isEmpty()) {
06807             return QDBusPendingReply<>(QDBusMessage::createError(
06808                 invalidationReason(),
06809                 invalidationMessage()
06810             ));
06811         }
06812 
06813         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06814                 this->staticInterfaceName(), QLatin1String("CloseTube"));
06815         callMessage << QVariant::fromValue(ID);
06816         return this->connection().asyncCall(callMessage, timeout);
06817     }
06818 
06838     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
06839     {
06840         if (!invalidationReason().isEmpty()) {
06841             return QDBusPendingReply<QString>(QDBusMessage::createError(
06842                 invalidationReason(),
06843                 invalidationMessage()
06844             ));
06845         }
06846 
06847         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06848                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
06849         callMessage << QVariant::fromValue(ID);
06850         return this->connection().asyncCall(callMessage, timeout);
06851     }
06852 
06873     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
06874     {
06875         if (!invalidationReason().isEmpty()) {
06876             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
06877                 invalidationReason(),
06878                 invalidationMessage()
06879             ));
06880         }
06881 
06882         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06883                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
06884         callMessage << QVariant::fromValue(ID);
06885         return this->connection().asyncCall(callMessage, timeout);
06886     }
06887 
06913     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
06914     {
06915         if (!invalidationReason().isEmpty()) {
06916             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
06917                 invalidationReason(),
06918                 invalidationMessage()
06919             ));
06920         }
06921 
06922         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06923                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
06924         callMessage << QVariant::fromValue(ID);
06925         return this->connection().asyncCall(callMessage, timeout);
06926     }
06927 
06928 Q_SIGNALS:
06958     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
06959 
06973     void TubeStateChanged(uint ID, uint state);
06974 
06985     void TubeClosed(uint ID);
06986 
07005     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
07006 
07021     void StreamTubeNewConnection(uint ID, uint handle);
07022 
07023 protected:
07024     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07025 };
07026 }
07027 }
07028 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
07029 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
07030 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
07031 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
07032 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
07033 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
07034 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
07035 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
07036 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
07037 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
07038 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
07039 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
07040 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
07041 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
07042 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
07043 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
07044 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
07045 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
07046 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
07047 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
07048 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
07049 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


Copyright © 2008-2010 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.4.1