00001
00002
00003
00004
00005
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
01244 inline Tp::PendingVariant *requestPropertyInitialChannels() const
01245 {
01246 return internalRequestProperty(QLatin1String("InitialChannels"));
01247 }
01248
01320 inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
01321 {
01322 return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
01323 }
01324
01347 inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
01348 {
01349 return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
01350 }
01351
01377 inline Tp::PendingVariant *requestPropertyInvitationMessage() const
01378 {
01379 return internalRequestProperty(QLatin1String("InvitationMessage"));
01380 }
01381
01445 inline Tp::PendingVariant *requestPropertyOriginalChannels() const
01446 {
01447 return internalRequestProperty(QLatin1String("OriginalChannels"));
01448 }
01449
01456 Tp::PendingVariantMap *requestAllProperties() const
01457 {
01458 return internalRequestAllProperties();
01459 }
01460
01461 Q_SIGNALS:
01483 void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01484
01505 void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01506
01507 protected:
01508 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01509 };
01510
01518 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01519 {
01520 Q_OBJECT
01521
01522 public:
01529 static inline QLatin1String staticInterfaceName()
01530 {
01531 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
01532 }
01533
01541 ChannelInterfaceDTMFInterface(
01542 const QString& busName,
01543 const QString& objectPath,
01544 QObject* parent = 0
01545 );
01546
01555 ChannelInterfaceDTMFInterface(
01556 const QDBusConnection& connection,
01557 const QString& busName,
01558 const QString& objectPath,
01559 QObject* parent = 0
01560 );
01561
01568 ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
01569
01577 explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
01578
01586 ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01587
01599 inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
01600 {
01601 return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
01602 }
01603
01616 inline Tp::PendingVariant *requestPropertyInitialTones() const
01617 {
01618 return internalRequestProperty(QLatin1String("InitialTones"));
01619 }
01620
01636 inline Tp::PendingVariant *requestPropertyDeferredTones() const
01637 {
01638 return internalRequestProperty(QLatin1String("DeferredTones"));
01639 }
01640
01647 Tp::PendingVariantMap *requestAllProperties() const
01648 {
01649 return internalRequestAllProperties();
01650 }
01651
01652 public Q_SLOTS:
01683 inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
01684 {
01685 if (!invalidationReason().isEmpty()) {
01686 return QDBusPendingReply<>(QDBusMessage::createError(
01687 invalidationReason(),
01688 invalidationMessage()
01689 ));
01690 }
01691
01692 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01693 this->staticInterfaceName(), QLatin1String("StartTone"));
01694 callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01695 return this->connection().asyncCall(callMessage, timeout);
01696 }
01697
01720 inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
01721 {
01722 if (!invalidationReason().isEmpty()) {
01723 return QDBusPendingReply<>(QDBusMessage::createError(
01724 invalidationReason(),
01725 invalidationMessage()
01726 ));
01727 }
01728
01729 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01730 this->staticInterfaceName(), QLatin1String("StopTone"));
01731 callMessage << QVariant::fromValue(streamID);
01732 return this->connection().asyncCall(callMessage, timeout);
01733 }
01734
01778 inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
01779 {
01780 if (!invalidationReason().isEmpty()) {
01781 return QDBusPendingReply<>(QDBusMessage::createError(
01782 invalidationReason(),
01783 invalidationMessage()
01784 ));
01785 }
01786
01787 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01788 this->staticInterfaceName(), QLatin1String("MultipleTones"));
01789 callMessage << QVariant::fromValue(tones);
01790 return this->connection().asyncCall(callMessage, timeout);
01791 }
01792
01793 Q_SIGNALS:
01819 void TonesDeferred(const QString& tones);
01820
01835 void SendingTones(const QString& tones);
01836
01846 void StoppedTones(bool cancelled);
01847
01848 protected:
01849 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01850 };
01851
01859 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
01860 {
01861 Q_OBJECT
01862
01863 public:
01870 static inline QLatin1String staticInterfaceName()
01871 {
01872 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
01873 }
01874
01882 ChannelInterfaceGroupInterface(
01883 const QString& busName,
01884 const QString& objectPath,
01885 QObject* parent = 0
01886 );
01887
01896 ChannelInterfaceGroupInterface(
01897 const QDBusConnection& connection,
01898 const QString& busName,
01899 const QString& objectPath,
01900 QObject* parent = 0
01901 );
01902
01909 ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01910
01918 explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01919
01927 ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01928
01941 inline Tp::PendingVariant *requestPropertyGroupFlags() const
01942 {
01943 return internalRequestProperty(QLatin1String("GroupFlags"));
01944 }
01945
01961 inline Tp::PendingVariant *requestPropertyHandleOwners() const
01962 {
01963 return internalRequestProperty(QLatin1String("HandleOwners"));
01964 }
01965
01976 inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
01977 {
01978 return internalRequestProperty(QLatin1String("LocalPendingMembers"));
01979 }
01980
01990 inline Tp::PendingVariant *requestPropertyMembers() const
01991 {
01992 return internalRequestProperty(QLatin1String("Members"));
01993 }
01994
02005 inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
02006 {
02007 return internalRequestProperty(QLatin1String("RemotePendingMembers"));
02008 }
02009
02024 inline Tp::PendingVariant *requestPropertySelfHandle() const
02025 {
02026 return internalRequestProperty(QLatin1String("SelfHandle"));
02027 }
02028
02035 Tp::PendingVariantMap *requestAllProperties() const
02036 {
02037 return internalRequestAllProperties();
02038 }
02039
02040 public Q_SLOTS:
02069 inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02070 {
02071 if (!invalidationReason().isEmpty()) {
02072 return QDBusPendingReply<>(QDBusMessage::createError(
02073 invalidationReason(),
02074 invalidationMessage()
02075 ));
02076 }
02077
02078 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02079 this->staticInterfaceName(), QLatin1String("AddMembers"));
02080 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02081 return this->connection().asyncCall(callMessage, timeout);
02082 }
02083
02106 inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
02107 {
02108 if (!invalidationReason().isEmpty()) {
02109 return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02110 invalidationReason(),
02111 invalidationMessage()
02112 ));
02113 }
02114
02115 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02116 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
02117 return this->connection().asyncCall(callMessage, timeout);
02118 }
02119
02134 inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
02135 {
02136 if (!invalidationReason().isEmpty()) {
02137 return QDBusPendingReply<uint>(QDBusMessage::createError(
02138 invalidationReason(),
02139 invalidationMessage()
02140 ));
02141 }
02142
02143 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02144 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
02145 return this->connection().asyncCall(callMessage, timeout);
02146 }
02147
02173 inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
02174 {
02175 if (!invalidationReason().isEmpty()) {
02176 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02177 invalidationReason(),
02178 invalidationMessage()
02179 ));
02180 }
02181
02182 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02183 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
02184 callMessage << QVariant::fromValue(handles);
02185 return this->connection().asyncCall(callMessage, timeout);
02186 }
02187
02199 inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
02200 {
02201 if (!invalidationReason().isEmpty()) {
02202 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02203 invalidationReason(),
02204 invalidationMessage()
02205 ));
02206 }
02207
02208 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02209 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
02210 return this->connection().asyncCall(callMessage, timeout);
02211 }
02212
02231 inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
02232 {
02233 if (!invalidationReason().isEmpty()) {
02234 return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
02235 invalidationReason(),
02236 invalidationMessage()
02237 ));
02238 }
02239
02240 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02241 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
02242 return this->connection().asyncCall(callMessage, timeout);
02243 }
02244
02255 inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
02256 {
02257 if (!invalidationReason().isEmpty()) {
02258 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02259 invalidationReason(),
02260 invalidationMessage()
02261 ));
02262 }
02263
02264 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02265 this->staticInterfaceName(), QLatin1String("GetMembers"));
02266 return this->connection().asyncCall(callMessage, timeout);
02267 }
02268
02280 inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
02281 {
02282 if (!invalidationReason().isEmpty()) {
02283 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02284 invalidationReason(),
02285 invalidationMessage()
02286 ));
02287 }
02288
02289 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02290 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
02291 return this->connection().asyncCall(callMessage, timeout);
02292 }
02293
02304 inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
02305 {
02306 if (!invalidationReason().isEmpty()) {
02307 return QDBusPendingReply<uint>(QDBusMessage::createError(
02308 invalidationReason(),
02309 invalidationMessage()
02310 ));
02311 }
02312
02313 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02314 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
02315 return this->connection().asyncCall(callMessage, timeout);
02316 }
02317
02371 inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02372 {
02373 if (!invalidationReason().isEmpty()) {
02374 return QDBusPendingReply<>(QDBusMessage::createError(
02375 invalidationReason(),
02376 invalidationMessage()
02377 ));
02378 }
02379
02380 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02381 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
02382 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02383 return this->connection().asyncCall(callMessage, timeout);
02384 }
02385
02410 inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
02411 {
02412 if (!invalidationReason().isEmpty()) {
02413 return QDBusPendingReply<>(QDBusMessage::createError(
02414 invalidationReason(),
02415 invalidationMessage()
02416 ));
02417 }
02418
02419 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02420 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
02421 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
02422 return this->connection().asyncCall(callMessage, timeout);
02423 }
02424
02425 Q_SIGNALS:
02444 void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
02445
02455 void SelfHandleChanged(uint selfHandle);
02456
02471 void GroupFlagsChanged(uint added, uint removed);
02472
02524 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);
02525
02630 void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
02631
02632 protected:
02633 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02634 };
02635
02643 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
02644 {
02645 Q_OBJECT
02646
02647 public:
02654 static inline QLatin1String staticInterfaceName()
02655 {
02656 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
02657 }
02658
02666 ChannelInterfaceHoldInterface(
02667 const QString& busName,
02668 const QString& objectPath,
02669 QObject* parent = 0
02670 );
02671
02680 ChannelInterfaceHoldInterface(
02681 const QDBusConnection& connection,
02682 const QString& busName,
02683 const QString& objectPath,
02684 QObject* parent = 0
02685 );
02686
02693 ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
02694
02702 explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
02703
02711 ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02712
02719 Tp::PendingVariantMap *requestAllProperties() const
02720 {
02721 return internalRequestAllProperties();
02722 }
02723
02724 public Q_SLOTS:
02743 inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
02744 {
02745 if (!invalidationReason().isEmpty()) {
02746 return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
02747 invalidationReason(),
02748 invalidationMessage()
02749 ));
02750 }
02751
02752 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02753 this->staticInterfaceName(), QLatin1String("GetHoldState"));
02754 return this->connection().asyncCall(callMessage, timeout);
02755 }
02756
02818 inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
02819 {
02820 if (!invalidationReason().isEmpty()) {
02821 return QDBusPendingReply<>(QDBusMessage::createError(
02822 invalidationReason(),
02823 invalidationMessage()
02824 ));
02825 }
02826
02827 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02828 this->staticInterfaceName(), QLatin1String("RequestHold"));
02829 callMessage << QVariant::fromValue(hold);
02830 return this->connection().asyncCall(callMessage, timeout);
02831 }
02832
02833 Q_SIGNALS:
02850 void HoldStateChanged(uint holdState, uint reason);
02851
02852 protected:
02853 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02854 };
02855
02863 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
02864 {
02865 Q_OBJECT
02866
02867 public:
02874 static inline QLatin1String staticInterfaceName()
02875 {
02876 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
02877 }
02878
02886 ChannelInterfaceMediaSignallingInterface(
02887 const QString& busName,
02888 const QString& objectPath,
02889 QObject* parent = 0
02890 );
02891
02900 ChannelInterfaceMediaSignallingInterface(
02901 const QDBusConnection& connection,
02902 const QString& busName,
02903 const QString& objectPath,
02904 QObject* parent = 0
02905 );
02906
02913 ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
02914
02922 explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
02923
02931 ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02932
02939 Tp::PendingVariantMap *requestAllProperties() const
02940 {
02941 return internalRequestAllProperties();
02942 }
02943
02944 public Q_SLOTS:
02956 inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
02957 {
02958 if (!invalidationReason().isEmpty()) {
02959 return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02960 invalidationReason(),
02961 invalidationMessage()
02962 ));
02963 }
02964
02965 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02966 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
02967 return this->connection().asyncCall(callMessage, timeout);
02968 }
02969
02970 Q_SIGNALS:
02986 void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02987
02988 protected:
02989 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02990 };
02991
02999 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
03000 {
03001 Q_OBJECT
03002
03003 public:
03010 static inline QLatin1String staticInterfaceName()
03011 {
03012 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
03013 }
03014
03022 ChannelInterfaceMessagesInterface(
03023 const QString& busName,
03024 const QString& objectPath,
03025 QObject* parent = 0
03026 );
03027
03036 ChannelInterfaceMessagesInterface(
03037 const QDBusConnection& connection,
03038 const QString& busName,
03039 const QString& objectPath,
03040 QObject* parent = 0
03041 );
03042
03049 ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
03050
03058 explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
03059
03067 ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03068
03120 inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
03121 {
03122 return internalRequestProperty(QLatin1String("SupportedContentTypes"));
03123 }
03124
03134 inline Tp::PendingVariant *requestPropertyMessageTypes() const
03135 {
03136 return internalRequestProperty(QLatin1String("MessageTypes"));
03137 }
03138
03148 inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
03149 {
03150 return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
03151 }
03152
03171 inline Tp::PendingVariant *requestPropertyPendingMessages() const
03172 {
03173 return internalRequestProperty(QLatin1String("PendingMessages"));
03174 }
03175
03185 inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
03186 {
03187 return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
03188 }
03189
03196 Tp::PendingVariantMap *requestAllProperties() const
03197 {
03198 return internalRequestAllProperties();
03199 }
03200
03201 public Q_SLOTS:
03262 inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
03263 {
03264 if (!invalidationReason().isEmpty()) {
03265 return QDBusPendingReply<QString>(QDBusMessage::createError(
03266 invalidationReason(),
03267 invalidationMessage()
03268 ));
03269 }
03270
03271 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03272 this->staticInterfaceName(), QLatin1String("SendMessage"));
03273 callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
03274 return this->connection().asyncCall(callMessage, timeout);
03275 }
03276
03315 inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
03316 {
03317 if (!invalidationReason().isEmpty()) {
03318 return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
03319 invalidationReason(),
03320 invalidationMessage()
03321 ));
03322 }
03323
03324 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03325 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
03326 callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
03327 return this->connection().asyncCall(callMessage, timeout);
03328 }
03329
03330 Q_SIGNALS:
03386 void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
03387
03401 void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
03402
03421 void MessageReceived(const Tp::MessagePartList& message);
03422
03423 protected:
03424 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03425 };
03426
03434 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
03435 {
03436 Q_OBJECT
03437
03438 public:
03445 static inline QLatin1String staticInterfaceName()
03446 {
03447 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
03448 }
03449
03457 ChannelInterfacePasswordInterface(
03458 const QString& busName,
03459 const QString& objectPath,
03460 QObject* parent = 0
03461 );
03462
03471 ChannelInterfacePasswordInterface(
03472 const QDBusConnection& connection,
03473 const QString& busName,
03474 const QString& objectPath,
03475 QObject* parent = 0
03476 );
03477
03484 ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
03485
03493 explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
03494
03502 ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03503
03510 Tp::PendingVariantMap *requestAllProperties() const
03511 {
03512 return internalRequestAllProperties();
03513 }
03514
03515 public Q_SLOTS:
03533 inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
03534 {
03535 if (!invalidationReason().isEmpty()) {
03536 return QDBusPendingReply<uint>(QDBusMessage::createError(
03537 invalidationReason(),
03538 invalidationMessage()
03539 ));
03540 }
03541
03542 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03543 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
03544 return this->connection().asyncCall(callMessage, timeout);
03545 }
03546
03567 inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
03568 {
03569 if (!invalidationReason().isEmpty()) {
03570 return QDBusPendingReply<bool>(QDBusMessage::createError(
03571 invalidationReason(),
03572 invalidationMessage()
03573 ));
03574 }
03575
03576 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03577 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
03578 callMessage << QVariant::fromValue(password);
03579 return this->connection().asyncCall(callMessage, timeout);
03580 }
03581
03582 Q_SIGNALS:
03597 void PasswordFlagsChanged(uint added, uint removed);
03598
03599 protected:
03600 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03601 };
03602
03610 class TELEPATHY_QT4_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
03611 {
03612 Q_OBJECT
03613
03614 public:
03621 static inline QLatin1String staticInterfaceName()
03622 {
03623 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
03624 }
03625
03633 ChannelInterfaceSASLAuthenticationInterface(
03634 const QString& busName,
03635 const QString& objectPath,
03636 QObject* parent = 0
03637 );
03638
03647 ChannelInterfaceSASLAuthenticationInterface(
03648 const QDBusConnection& connection,
03649 const QString& busName,
03650 const QString& objectPath,
03651 QObject* parent = 0
03652 );
03653
03660 ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
03661
03669 explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
03670
03678 ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03679
03700 inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
03701 {
03702 return internalRequestProperty(QLatin1String("AvailableMechanisms"));
03703 }
03704
03724 inline Tp::PendingVariant *requestPropertyHasInitialData() const
03725 {
03726 return internalRequestProperty(QLatin1String("HasInitialData"));
03727 }
03728
03747 inline Tp::PendingVariant *requestPropertyCanTryAgain() const
03748 {
03749 return internalRequestProperty(QLatin1String("CanTryAgain"));
03750 }
03751
03763 inline Tp::PendingVariant *requestPropertySASLStatus() const
03764 {
03765 return internalRequestProperty(QLatin1String("SASLStatus"));
03766 }
03767
03794 inline Tp::PendingVariant *requestPropertySASLError() const
03795 {
03796 return internalRequestProperty(QLatin1String("SASLError"));
03797 }
03798
03818 inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
03819 {
03820 return internalRequestProperty(QLatin1String("SASLErrorDetails"));
03821 }
03822
03885 inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
03886 {
03887 return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
03888 }
03889
03949 inline Tp::PendingVariant *requestPropertyDefaultUsername() const
03950 {
03951 return internalRequestProperty(QLatin1String("DefaultUsername"));
03952 }
03953
03979 inline Tp::PendingVariant *requestPropertyDefaultRealm() const
03980 {
03981 return internalRequestProperty(QLatin1String("DefaultRealm"));
03982 }
03983
04003 inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
04004 {
04005 return internalRequestProperty(QLatin1String("MaySaveResponse"));
04006 }
04007
04014 Tp::PendingVariantMap *requestAllProperties() const
04015 {
04016 return internalRequestAllProperties();
04017 }
04018
04019 public Q_SLOTS:
04044 inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
04045 {
04046 if (!invalidationReason().isEmpty()) {
04047 return QDBusPendingReply<>(QDBusMessage::createError(
04048 invalidationReason(),
04049 invalidationMessage()
04050 ));
04051 }
04052
04053 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04054 this->staticInterfaceName(), QLatin1String("StartMechanism"));
04055 callMessage << QVariant::fromValue(mechanism);
04056 return this->connection().asyncCall(callMessage, timeout);
04057 }
04058
04111 inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, 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("StartMechanismWithData"));
04122 callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
04123 return this->connection().asyncCall(callMessage, timeout);
04124 }
04125
04141 inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
04142 {
04143 if (!invalidationReason().isEmpty()) {
04144 return QDBusPendingReply<>(QDBusMessage::createError(
04145 invalidationReason(),
04146 invalidationMessage()
04147 ));
04148 }
04149
04150 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04151 this->staticInterfaceName(), QLatin1String("Respond"));
04152 callMessage << QVariant::fromValue(responseData);
04153 return this->connection().asyncCall(callMessage, timeout);
04154 }
04155
04182 inline QDBusPendingReply<> AcceptSASL(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("AcceptSASL"));
04193 return this->connection().asyncCall(callMessage, timeout);
04194 }
04195
04222 inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
04223 {
04224 if (!invalidationReason().isEmpty()) {
04225 return QDBusPendingReply<>(QDBusMessage::createError(
04226 invalidationReason(),
04227 invalidationMessage()
04228 ));
04229 }
04230
04231 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04232 this->staticInterfaceName(), QLatin1String("AbortSASL"));
04233 callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
04234 return this->connection().asyncCall(callMessage, timeout);
04235 }
04236
04237 Q_SIGNALS:
04255 void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
04256
04274 void NewChallenge(const QByteArray& challengeData);
04275
04276 protected:
04277 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04278 };
04279
04287 class TELEPATHY_QT4_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
04288 {
04289 Q_OBJECT
04290
04291 public:
04298 static inline QLatin1String staticInterfaceName()
04299 {
04300 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
04301 }
04302
04310 ChannelInterfaceSecurableInterface(
04311 const QString& busName,
04312 const QString& objectPath,
04313 QObject* parent = 0
04314 );
04315
04324 ChannelInterfaceSecurableInterface(
04325 const QDBusConnection& connection,
04326 const QString& busName,
04327 const QString& objectPath,
04328 QObject* parent = 0
04329 );
04330
04337 ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
04338
04346 explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
04347
04355 ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04356
04376 inline Tp::PendingVariant *requestPropertyEncrypted() const
04377 {
04378 return internalRequestProperty(QLatin1String("Encrypted"));
04379 }
04380
04395 inline Tp::PendingVariant *requestPropertyVerified() const
04396 {
04397 return internalRequestProperty(QLatin1String("Verified"));
04398 }
04399
04406 Tp::PendingVariantMap *requestAllProperties() const
04407 {
04408 return internalRequestAllProperties();
04409 }
04410
04411 protected:
04412 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04413 };
04414
04422 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
04423 {
04424 Q_OBJECT
04425
04426 public:
04433 static inline QLatin1String staticInterfaceName()
04434 {
04435 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
04436 }
04437
04445 ChannelInterfaceServicePointInterface(
04446 const QString& busName,
04447 const QString& objectPath,
04448 QObject* parent = 0
04449 );
04450
04459 ChannelInterfaceServicePointInterface(
04460 const QDBusConnection& connection,
04461 const QString& busName,
04462 const QString& objectPath,
04463 QObject* parent = 0
04464 );
04465
04472 ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
04473
04481 explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
04482
04490 ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04491
04509 inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
04510 {
04511 return internalRequestProperty(QLatin1String("InitialServicePoint"));
04512 }
04513
04526 inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
04527 {
04528 return internalRequestProperty(QLatin1String("CurrentServicePoint"));
04529 }
04530
04537 Tp::PendingVariantMap *requestAllProperties() const
04538 {
04539 return internalRequestAllProperties();
04540 }
04541
04542 Q_SIGNALS:
04559 void ServicePointChanged(const Tp::ServicePoint& servicePoint);
04560
04561 protected:
04562 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04563 };
04564
04572 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
04573 {
04574 Q_OBJECT
04575
04576 public:
04583 static inline QLatin1String staticInterfaceName()
04584 {
04585 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
04586 }
04587
04595 ChannelInterfaceTubeInterface(
04596 const QString& busName,
04597 const QString& objectPath,
04598 QObject* parent = 0
04599 );
04600
04609 ChannelInterfaceTubeInterface(
04610 const QDBusConnection& connection,
04611 const QString& busName,
04612 const QString& objectPath,
04613 QObject* parent = 0
04614 );
04615
04622 ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
04623
04631 explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
04632
04640 ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04641
04685 inline Tp::PendingVariant *requestPropertyParameters() const
04686 {
04687 return internalRequestProperty(QLatin1String("Parameters"));
04688 }
04689
04703 inline Tp::PendingVariant *requestPropertyState() const
04704 {
04705 return internalRequestProperty(QLatin1String("State"));
04706 }
04707
04714 Tp::PendingVariantMap *requestAllProperties() const
04715 {
04716 return internalRequestAllProperties();
04717 }
04718
04719 Q_SIGNALS:
04730 void TubeChannelStateChanged(uint state);
04731
04732 protected:
04733 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04734 };
04735
04743 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
04744 {
04745 Q_OBJECT
04746
04747 public:
04754 static inline QLatin1String staticInterfaceName()
04755 {
04756 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
04757 }
04758
04766 ChannelTypeContactListInterface(
04767 const QString& busName,
04768 const QString& objectPath,
04769 QObject* parent = 0
04770 );
04771
04780 ChannelTypeContactListInterface(
04781 const QDBusConnection& connection,
04782 const QString& busName,
04783 const QString& objectPath,
04784 QObject* parent = 0
04785 );
04786
04793 ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
04794
04802 explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
04803
04811 ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04812
04819 Tp::PendingVariantMap *requestAllProperties() const
04820 {
04821 return internalRequestAllProperties();
04822 }
04823
04824 protected:
04825 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04826 };
04827
04835 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
04836 {
04837 Q_OBJECT
04838
04839 public:
04846 static inline QLatin1String staticInterfaceName()
04847 {
04848 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
04849 }
04850
04858 ChannelTypeContactSearchInterface(
04859 const QString& busName,
04860 const QString& objectPath,
04861 QObject* parent = 0
04862 );
04863
04872 ChannelTypeContactSearchInterface(
04873 const QDBusConnection& connection,
04874 const QString& busName,
04875 const QString& objectPath,
04876 QObject* parent = 0
04877 );
04878
04885 ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
04886
04894 explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
04895
04903 ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04904
04915 inline Tp::PendingVariant *requestPropertySearchState() const
04916 {
04917 return internalRequestProperty(QLatin1String("SearchState"));
04918 }
04919
04943 inline Tp::PendingVariant *requestPropertyLimit() const
04944 {
04945 return internalRequestProperty(QLatin1String("Limit"));
04946 }
04947
04962 inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
04963 {
04964 return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
04965 }
04966
04987 inline Tp::PendingVariant *requestPropertyServer() const
04988 {
04989 return internalRequestProperty(QLatin1String("Server"));
04990 }
04991
04998 Tp::PendingVariantMap *requestAllProperties() const
04999 {
05000 return internalRequestAllProperties();
05001 }
05002
05003 public Q_SLOTS:
05021 inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
05022 {
05023 if (!invalidationReason().isEmpty()) {
05024 return QDBusPendingReply<>(QDBusMessage::createError(
05025 invalidationReason(),
05026 invalidationMessage()
05027 ));
05028 }
05029
05030 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05031 this->staticInterfaceName(), QLatin1String("Search"));
05032 callMessage << QVariant::fromValue(terms);
05033 return this->connection().asyncCall(callMessage, timeout);
05034 }
05035
05048 inline QDBusPendingReply<> More(int timeout = -1)
05049 {
05050 if (!invalidationReason().isEmpty()) {
05051 return QDBusPendingReply<>(QDBusMessage::createError(
05052 invalidationReason(),
05053 invalidationMessage()
05054 ));
05055 }
05056
05057 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05058 this->staticInterfaceName(), QLatin1String("More"));
05059 return this->connection().asyncCall(callMessage, timeout);
05060 }
05061
05092 inline QDBusPendingReply<> Stop(int timeout = -1)
05093 {
05094 if (!invalidationReason().isEmpty()) {
05095 return QDBusPendingReply<>(QDBusMessage::createError(
05096 invalidationReason(),
05097 invalidationMessage()
05098 ));
05099 }
05100
05101 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05102 this->staticInterfaceName(), QLatin1String("Stop"));
05103 return this->connection().asyncCall(callMessage, timeout);
05104 }
05105
05106 Q_SIGNALS:
05150 void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
05151
05164 void SearchResultReceived(const Tp::ContactSearchResultMap& result);
05165
05166 protected:
05167 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05168 };
05169
05177 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
05178 {
05179 Q_OBJECT
05180
05181 public:
05188 static inline QLatin1String staticInterfaceName()
05189 {
05190 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
05191 }
05192
05200 ChannelTypeFileTransferInterface(
05201 const QString& busName,
05202 const QString& objectPath,
05203 QObject* parent = 0
05204 );
05205
05214 ChannelTypeFileTransferInterface(
05215 const QDBusConnection& connection,
05216 const QString& busName,
05217 const QString& objectPath,
05218 QObject* parent = 0
05219 );
05220
05227 ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
05228
05236 explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
05237
05245 ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05246
05257 inline Tp::PendingVariant *requestPropertyState() const
05258 {
05259 return internalRequestProperty(QLatin1String("State"));
05260 }
05261
05277 inline Tp::PendingVariant *requestPropertyContentType() const
05278 {
05279 return internalRequestProperty(QLatin1String("ContentType"));
05280 }
05281
05301 inline Tp::PendingVariant *requestPropertyFilename() const
05302 {
05303 return internalRequestProperty(QLatin1String("Filename"));
05304 }
05305
05327 inline Tp::PendingVariant *requestPropertySize() const
05328 {
05329 return internalRequestProperty(QLatin1String("Size"));
05330 }
05331
05356 inline Tp::PendingVariant *requestPropertyContentHashType() const
05357 {
05358 return internalRequestProperty(QLatin1String("ContentHashType"));
05359 }
05360
05379 inline Tp::PendingVariant *requestPropertyContentHash() const
05380 {
05381 return internalRequestProperty(QLatin1String("ContentHash"));
05382 }
05383
05399 inline Tp::PendingVariant *requestPropertyDescription() const
05400 {
05401 return internalRequestProperty(QLatin1String("Description"));
05402 }
05403
05418 inline Tp::PendingVariant *requestPropertyDate() const
05419 {
05420 return internalRequestProperty(QLatin1String("Date"));
05421 }
05422
05449 inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
05450 {
05451 return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
05452 }
05453
05465 inline Tp::PendingVariant *requestPropertyTransferredBytes() const
05466 {
05467 return internalRequestProperty(QLatin1String("TransferredBytes"));
05468 }
05469
05490 inline Tp::PendingVariant *requestPropertyInitialOffset() const
05491 {
05492 return internalRequestProperty(QLatin1String("InitialOffset"));
05493 }
05494
05527 inline Tp::PendingVariant *requestPropertyURI() const
05528 {
05529 return internalRequestProperty(QLatin1String("URI"));
05530 }
05531
05564 inline Tp::PendingOperation *setPropertyURI(QString newValue)
05565 {
05566 return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
05567 }
05568
05575 Tp::PendingVariantMap *requestAllProperties() const
05576 {
05577 return internalRequestAllProperties();
05578 }
05579
05580 public Q_SLOTS:
05625 inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
05626 {
05627 if (!invalidationReason().isEmpty()) {
05628 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05629 invalidationReason(),
05630 invalidationMessage()
05631 ));
05632 }
05633
05634 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05635 this->staticInterfaceName(), QLatin1String("AcceptFile"));
05636 callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
05637 return this->connection().asyncCall(callMessage, timeout);
05638 }
05639
05673 inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
05674 {
05675 if (!invalidationReason().isEmpty()) {
05676 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05677 invalidationReason(),
05678 invalidationMessage()
05679 ));
05680 }
05681
05682 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05683 this->staticInterfaceName(), QLatin1String("ProvideFile"));
05684 callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05685 return this->connection().asyncCall(callMessage, timeout);
05686 }
05687
05688 Q_SIGNALS:
05706 void FileTransferStateChanged(uint state, uint reason);
05707
05720 void TransferredBytesChanged(qulonglong count);
05721
05733 void InitialOffsetDefined(qulonglong initialOffset);
05734
05746 void URIDefined(const QString& URI);
05747
05748 protected:
05749 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05750 };
05751
05759 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
05760 {
05761 Q_OBJECT
05762
05763 public:
05770 static inline QLatin1String staticInterfaceName()
05771 {
05772 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
05773 }
05774
05782 ChannelTypeRoomListInterface(
05783 const QString& busName,
05784 const QString& objectPath,
05785 QObject* parent = 0
05786 );
05787
05796 ChannelTypeRoomListInterface(
05797 const QDBusConnection& connection,
05798 const QString& busName,
05799 const QString& objectPath,
05800 QObject* parent = 0
05801 );
05802
05809 ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
05810
05818 explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
05819
05827 ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05828
05842 inline Tp::PendingVariant *requestPropertyServer() const
05843 {
05844 return internalRequestProperty(QLatin1String("Server"));
05845 }
05846
05853 Tp::PendingVariantMap *requestAllProperties() const
05854 {
05855 return internalRequestAllProperties();
05856 }
05857
05858 public Q_SLOTS:
05874 inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
05875 {
05876 if (!invalidationReason().isEmpty()) {
05877 return QDBusPendingReply<bool>(QDBusMessage::createError(
05878 invalidationReason(),
05879 invalidationMessage()
05880 ));
05881 }
05882
05883 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05884 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
05885 return this->connection().asyncCall(callMessage, timeout);
05886 }
05887
05901 inline QDBusPendingReply<> ListRooms(int timeout = -1)
05902 {
05903 if (!invalidationReason().isEmpty()) {
05904 return QDBusPendingReply<>(QDBusMessage::createError(
05905 invalidationReason(),
05906 invalidationMessage()
05907 ));
05908 }
05909
05910 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05911 this->staticInterfaceName(), QLatin1String("ListRooms"));
05912 return this->connection().asyncCall(callMessage, timeout);
05913 }
05914
05927 inline QDBusPendingReply<> StopListing(int timeout = -1)
05928 {
05929 if (!invalidationReason().isEmpty()) {
05930 return QDBusPendingReply<>(QDBusMessage::createError(
05931 invalidationReason(),
05932 invalidationMessage()
05933 ));
05934 }
05935
05936 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05937 this->staticInterfaceName(), QLatin1String("StopListing"));
05938 return this->connection().asyncCall(callMessage, timeout);
05939 }
05940
05941 Q_SIGNALS:
05995 void GotRooms(const Tp::RoomInfoList& rooms);
05996
06007 void ListingRooms(bool listing);
06008
06009 protected:
06010 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06011 };
06012
06020 class TELEPATHY_QT4_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
06021 {
06022 Q_OBJECT
06023
06024 public:
06031 static inline QLatin1String staticInterfaceName()
06032 {
06033 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
06034 }
06035
06043 ChannelTypeServerAuthenticationInterface(
06044 const QString& busName,
06045 const QString& objectPath,
06046 QObject* parent = 0
06047 );
06048
06057 ChannelTypeServerAuthenticationInterface(
06058 const QDBusConnection& connection,
06059 const QString& busName,
06060 const QString& objectPath,
06061 QObject* parent = 0
06062 );
06063
06070 ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
06071
06079 explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
06080
06088 ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06089
06104 inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
06105 {
06106 return internalRequestProperty(QLatin1String("AuthenticationMethod"));
06107 }
06108
06115 Tp::PendingVariantMap *requestAllProperties() const
06116 {
06117 return internalRequestAllProperties();
06118 }
06119
06120 protected:
06121 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06122 };
06123
06131 class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
06132 {
06133 Q_OBJECT
06134
06135 public:
06142 static inline QLatin1String staticInterfaceName()
06143 {
06144 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
06145 }
06146
06154 ChannelTypeServerTLSConnectionInterface(
06155 const QString& busName,
06156 const QString& objectPath,
06157 QObject* parent = 0
06158 );
06159
06168 ChannelTypeServerTLSConnectionInterface(
06169 const QDBusConnection& connection,
06170 const QString& busName,
06171 const QString& objectPath,
06172 QObject* parent = 0
06173 );
06174
06181 ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
06182
06190 explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
06191
06199 ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06200
06211 inline Tp::PendingVariant *requestPropertyServerCertificate() const
06212 {
06213 return internalRequestProperty(QLatin1String("ServerCertificate"));
06214 }
06215
06229 inline Tp::PendingVariant *requestPropertyHostname() const
06230 {
06231 return internalRequestProperty(QLatin1String("Hostname"));
06232 }
06233
06260 inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
06261 {
06262 return internalRequestProperty(QLatin1String("ReferenceIdentities"));
06263 }
06264
06271 Tp::PendingVariantMap *requestAllProperties() const
06272 {
06273 return internalRequestAllProperties();
06274 }
06275
06276 protected:
06277 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06278 };
06279
06287 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
06288 {
06289 Q_OBJECT
06290
06291 public:
06298 static inline QLatin1String staticInterfaceName()
06299 {
06300 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
06301 }
06302
06310 ChannelTypeStreamTubeInterface(
06311 const QString& busName,
06312 const QString& objectPath,
06313 QObject* parent = 0
06314 );
06315
06324 ChannelTypeStreamTubeInterface(
06325 const QDBusConnection& connection,
06326 const QString& busName,
06327 const QString& objectPath,
06328 QObject* parent = 0
06329 );
06330
06337 ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
06338
06346 explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
06347
06355 ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06356
06377 inline Tp::PendingVariant *requestPropertyService() const
06378 {
06379 return internalRequestProperty(QLatin1String("Service"));
06380 }
06381
06414 inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
06415 {
06416 return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
06417 }
06418
06425 Tp::PendingVariantMap *requestAllProperties() const
06426 {
06427 return internalRequestAllProperties();
06428 }
06429
06430 public Q_SLOTS:
06461 inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
06462 {
06463 if (!invalidationReason().isEmpty()) {
06464 return QDBusPendingReply<>(QDBusMessage::createError(
06465 invalidationReason(),
06466 invalidationMessage()
06467 ));
06468 }
06469
06470 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06471 this->staticInterfaceName(), QLatin1String("Offer"));
06472 callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
06473 return this->connection().asyncCall(callMessage, timeout);
06474 }
06475
06514 inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
06515 {
06516 if (!invalidationReason().isEmpty()) {
06517 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06518 invalidationReason(),
06519 invalidationMessage()
06520 ));
06521 }
06522
06523 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06524 this->staticInterfaceName(), QLatin1String("Accept"));
06525 callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
06526 return this->connection().asyncCall(callMessage, timeout);
06527 }
06528
06529 Q_SIGNALS:
06566 void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
06567
06581 void NewLocalConnection(uint connectionID);
06582
06610 void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
06611
06612 protected:
06613 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06614 };
06615
06623 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
06624 {
06625 Q_OBJECT
06626
06627 public:
06634 static inline QLatin1String staticInterfaceName()
06635 {
06636 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
06637 }
06638
06646 ChannelTypeStreamedMediaInterface(
06647 const QString& busName,
06648 const QString& objectPath,
06649 QObject* parent = 0
06650 );
06651
06660 ChannelTypeStreamedMediaInterface(
06661 const QDBusConnection& connection,
06662 const QString& busName,
06663 const QString& objectPath,
06664 QObject* parent = 0
06665 );
06666
06673 ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
06674
06682 explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
06683
06691 ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06692
06779 inline Tp::PendingVariant *requestPropertyInitialAudio() const
06780 {
06781 return internalRequestProperty(QLatin1String("InitialAudio"));
06782 }
06783
06802 inline Tp::PendingVariant *requestPropertyInitialVideo() const
06803 {
06804 return internalRequestProperty(QLatin1String("InitialVideo"));
06805 }
06806
06847 inline Tp::PendingVariant *requestPropertyImmutableStreams() const
06848 {
06849 return internalRequestProperty(QLatin1String("ImmutableStreams"));
06850 }
06851
06858 Tp::PendingVariantMap *requestAllProperties() const
06859 {
06860 return internalRequestAllProperties();
06861 }
06862
06863 public Q_SLOTS:
06889 inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
06890 {
06891 if (!invalidationReason().isEmpty()) {
06892 return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
06893 invalidationReason(),
06894 invalidationMessage()
06895 ));
06896 }
06897
06898 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06899 this->staticInterfaceName(), QLatin1String("ListStreams"));
06900 return this->connection().asyncCall(callMessage, timeout);
06901 }
06902
06927 inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
06928 {
06929 if (!invalidationReason().isEmpty()) {
06930 return QDBusPendingReply<>(QDBusMessage::createError(
06931 invalidationReason(),
06932 invalidationMessage()
06933 ));
06934 }
06935
06936 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06937 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
06938 callMessage << QVariant::fromValue(streams);
06939 return this->connection().asyncCall(callMessage, timeout);
06940 }
06941
06976 inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
06977 {
06978 if (!invalidationReason().isEmpty()) {
06979 return QDBusPendingReply<>(QDBusMessage::createError(
06980 invalidationReason(),
06981 invalidationMessage()
06982 ));
06983 }
06984
06985 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06986 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
06987 callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
06988 return this->connection().asyncCall(callMessage, timeout);
06989 }
06990
07039 inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
07040 {
07041 if (!invalidationReason().isEmpty()) {
07042 return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
07043 invalidationReason(),
07044 invalidationMessage()
07045 ));
07046 }
07047
07048 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07049 this->staticInterfaceName(), QLatin1String("RequestStreams"));
07050 callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
07051 return this->connection().asyncCall(callMessage, timeout);
07052 }
07053
07054 Q_SIGNALS:
07119 void StreamAdded(uint streamID, uint contactHandle, uint streamType);
07120
07150 void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
07151
07169 void StreamError(uint streamID, uint errorCode, const QString& message);
07170
07180 void StreamRemoved(uint streamID);
07181
07195 void StreamStateChanged(uint streamID, uint streamState);
07196
07197 protected:
07198 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07199 };
07200
07208 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
07209 {
07210 Q_OBJECT
07211
07212 public:
07219 static inline QLatin1String staticInterfaceName()
07220 {
07221 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
07222 }
07223
07231 ChannelTypeTextInterface(
07232 const QString& busName,
07233 const QString& objectPath,
07234 QObject* parent = 0
07235 );
07236
07245 ChannelTypeTextInterface(
07246 const QDBusConnection& connection,
07247 const QString& busName,
07248 const QString& objectPath,
07249 QObject* parent = 0
07250 );
07251
07258 ChannelTypeTextInterface(Tp::DBusProxy *proxy);
07259
07267 explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
07268
07276 ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07277
07284 Tp::PendingVariantMap *requestAllProperties() const
07285 {
07286 return internalRequestAllProperties();
07287 }
07288
07289 public Q_SLOTS:
07305 inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
07306 {
07307 if (!invalidationReason().isEmpty()) {
07308 return QDBusPendingReply<>(QDBusMessage::createError(
07309 invalidationReason(),
07310 invalidationMessage()
07311 ));
07312 }
07313
07314 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07315 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
07316 callMessage << QVariant::fromValue(IDs);
07317 return this->connection().asyncCall(callMessage, timeout);
07318 }
07319
07335 inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
07336 {
07337 if (!invalidationReason().isEmpty()) {
07338 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
07339 invalidationReason(),
07340 invalidationMessage()
07341 ));
07342 }
07343
07344 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07345 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
07346 return this->connection().asyncCall(callMessage, timeout);
07347 }
07348
07377 inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
07378 {
07379 if (!invalidationReason().isEmpty()) {
07380 return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
07381 invalidationReason(),
07382 invalidationMessage()
07383 ));
07384 }
07385
07386 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07387 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
07388 callMessage << QVariant::fromValue(clear);
07389 return this->connection().asyncCall(callMessage, timeout);
07390 }
07391
07422 inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
07423 {
07424 if (!invalidationReason().isEmpty()) {
07425 return QDBusPendingReply<>(QDBusMessage::createError(
07426 invalidationReason(),
07427 invalidationMessage()
07428 ));
07429 }
07430
07431 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07432 this->staticInterfaceName(), QLatin1String("Send"));
07433 callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
07434 return this->connection().asyncCall(callMessage, timeout);
07435 }
07436
07437 Q_SIGNALS:
07445 void LostMessage();
07446
07480 void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
07481
07508 void SendError(uint error, uint timestamp, uint type, const QString& text);
07509
07531 void Sent(uint timestamp, uint type, const QString& text);
07532
07533 protected:
07534 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07535 };
07536
07544 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
07545 {
07546 Q_OBJECT
07547
07548 public:
07555 static inline QLatin1String staticInterfaceName()
07556 {
07557 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
07558 }
07559
07567 ChannelTypeTubesInterface(
07568 const QString& busName,
07569 const QString& objectPath,
07570 QObject* parent = 0
07571 );
07572
07581 ChannelTypeTubesInterface(
07582 const QDBusConnection& connection,
07583 const QString& busName,
07584 const QString& objectPath,
07585 QObject* parent = 0
07586 );
07587
07594 ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
07595
07603 explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
07604
07612 ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07613
07620 Tp::PendingVariantMap *requestAllProperties() const
07621 {
07622 return internalRequestAllProperties();
07623 }
07624
07625 public Q_SLOTS:
07660 inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
07661 {
07662 if (!invalidationReason().isEmpty()) {
07663 return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
07664 invalidationReason(),
07665 invalidationMessage()
07666 ));
07667 }
07668
07669 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07670 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
07671 return this->connection().asyncCall(callMessage, timeout);
07672 }
07673
07687 inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
07688 {
07689 if (!invalidationReason().isEmpty()) {
07690 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
07691 invalidationReason(),
07692 invalidationMessage()
07693 ));
07694 }
07695
07696 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07697 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
07698 return this->connection().asyncCall(callMessage, timeout);
07699 }
07700
07716 inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
07717 {
07718 if (!invalidationReason().isEmpty()) {
07719 return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
07720 invalidationReason(),
07721 invalidationMessage()
07722 ));
07723 }
07724
07725 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07726 this->staticInterfaceName(), QLatin1String("ListTubes"));
07727 return this->connection().asyncCall(callMessage, timeout);
07728 }
07729
07757 inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
07758 {
07759 if (!invalidationReason().isEmpty()) {
07760 return QDBusPendingReply<uint>(QDBusMessage::createError(
07761 invalidationReason(),
07762 invalidationMessage()
07763 ));
07764 }
07765
07766 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07767 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
07768 callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
07769 return this->connection().asyncCall(callMessage, timeout);
07770 }
07771
07827 inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
07828 {
07829 if (!invalidationReason().isEmpty()) {
07830 return QDBusPendingReply<uint>(QDBusMessage::createError(
07831 invalidationReason(),
07832 invalidationMessage()
07833 ));
07834 }
07835
07836 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07837 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
07838 callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
07839 return this->connection().asyncCall(callMessage, timeout);
07840 }
07841
07864 inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
07865 {
07866 if (!invalidationReason().isEmpty()) {
07867 return QDBusPendingReply<QString>(QDBusMessage::createError(
07868 invalidationReason(),
07869 invalidationMessage()
07870 ));
07871 }
07872
07873 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07874 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
07875 callMessage << QVariant::fromValue(ID);
07876 return this->connection().asyncCall(callMessage, timeout);
07877 }
07878
07916 inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
07917 {
07918 if (!invalidationReason().isEmpty()) {
07919 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
07920 invalidationReason(),
07921 invalidationMessage()
07922 ));
07923 }
07924
07925 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07926 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
07927 callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
07928 return this->connection().asyncCall(callMessage, timeout);
07929 }
07930
07945 inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
07946 {
07947 if (!invalidationReason().isEmpty()) {
07948 return QDBusPendingReply<>(QDBusMessage::createError(
07949 invalidationReason(),
07950 invalidationMessage()
07951 ));
07952 }
07953
07954 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07955 this->staticInterfaceName(), QLatin1String("CloseTube"));
07956 callMessage << QVariant::fromValue(ID);
07957 return this->connection().asyncCall(callMessage, timeout);
07958 }
07959
07979 inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
07980 {
07981 if (!invalidationReason().isEmpty()) {
07982 return QDBusPendingReply<QString>(QDBusMessage::createError(
07983 invalidationReason(),
07984 invalidationMessage()
07985 ));
07986 }
07987
07988 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07989 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
07990 callMessage << QVariant::fromValue(ID);
07991 return this->connection().asyncCall(callMessage, timeout);
07992 }
07993
08014 inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
08015 {
08016 if (!invalidationReason().isEmpty()) {
08017 return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
08018 invalidationReason(),
08019 invalidationMessage()
08020 ));
08021 }
08022
08023 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08024 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
08025 callMessage << QVariant::fromValue(ID);
08026 return this->connection().asyncCall(callMessage, timeout);
08027 }
08028
08054 inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
08055 {
08056 if (!invalidationReason().isEmpty()) {
08057 return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
08058 invalidationReason(),
08059 invalidationMessage()
08060 ));
08061 }
08062
08063 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08064 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
08065 callMessage << QVariant::fromValue(ID);
08066 return this->connection().asyncCall(callMessage, timeout);
08067 }
08068
08069 Q_SIGNALS:
08099 void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
08100
08114 void TubeStateChanged(uint ID, uint state);
08115
08126 void TubeClosed(uint ID);
08127
08146 void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
08147
08162 void StreamTubeNewConnection(uint ID, uint handle);
08163
08164 protected:
08165 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08166 };
08167 }
08168 }
08169 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
08170 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
08171 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
08172 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
08173 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
08174 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
08175 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
08176 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
08177 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
08178 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
08179 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
08180 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
08181 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
08182 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
08183 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
08184 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
08185 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
08186 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
08187 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
08188 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
08189 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
08190 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
08191 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
08192 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
08193 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)