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