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 ChannelInterfaceCaptchaAuthenticationInterface : public Tp::AbstractInterface
00927 {
00928 Q_OBJECT
00929
00930 public:
00937 static inline QLatin1String staticInterfaceName()
00938 {
00939 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.CaptchaAuthentication1");
00940 }
00941
00949 ChannelInterfaceCaptchaAuthenticationInterface(
00950 const QString& busName,
00951 const QString& objectPath,
00952 QObject* parent = 0
00953 );
00954
00963 ChannelInterfaceCaptchaAuthenticationInterface(
00964 const QDBusConnection& connection,
00965 const QString& busName,
00966 const QString& objectPath,
00967 QObject* parent = 0
00968 );
00969
00976 ChannelInterfaceCaptchaAuthenticationInterface(Tp::DBusProxy *proxy);
00977
00985 explicit ChannelInterfaceCaptchaAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
00986
00994 ChannelInterfaceCaptchaAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00995
01017 inline Tp::PendingVariant *requestPropertyCanRetryCaptcha() const
01018 {
01019 return internalRequestProperty(QLatin1String("CanRetryCaptcha"));
01020 }
01021
01047 inline Tp::PendingVariant *requestPropertyCaptchaStatus() const
01048 {
01049 return internalRequestProperty(QLatin1String("CaptchaStatus"));
01050 }
01051
01085 inline Tp::PendingVariant *requestPropertyCaptchaError() const
01086 {
01087 return internalRequestProperty(QLatin1String("CaptchaError"));
01088 }
01089
01111 inline Tp::PendingVariant *requestPropertyCaptchaErrorDetails() const
01112 {
01113 return internalRequestProperty(QLatin1String("CaptchaErrorDetails"));
01114 }
01115
01122 Tp::PendingVariantMap *requestAllProperties() const
01123 {
01124 return internalRequestAllProperties();
01125 }
01126
01127 public Q_SLOTS:
01181 inline QDBusPendingReply<Tp::CaptchaInfoList, uint, QString> GetCaptchas(int timeout = -1)
01182 {
01183 if (!invalidationReason().isEmpty()) {
01184 return QDBusPendingReply<Tp::CaptchaInfoList, uint, QString>(QDBusMessage::createError(
01185 invalidationReason(),
01186 invalidationMessage()
01187 ));
01188 }
01189
01190 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01191 this->staticInterfaceName(), QLatin1String("GetCaptchas"));
01192 return this->connection().asyncCall(callMessage, timeout);
01193 }
01194
01232 inline QDBusPendingReply<QByteArray> GetCaptchaData(uint ID, const QString& mimeType, int timeout = -1)
01233 {
01234 if (!invalidationReason().isEmpty()) {
01235 return QDBusPendingReply<QByteArray>(QDBusMessage::createError(
01236 invalidationReason(),
01237 invalidationMessage()
01238 ));
01239 }
01240
01241 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01242 this->staticInterfaceName(), QLatin1String("GetCaptchaData"));
01243 callMessage << QVariant::fromValue(ID) << QVariant::fromValue(mimeType);
01244 return this->connection().asyncCall(callMessage, timeout);
01245 }
01246
01265 inline QDBusPendingReply<> AnswerCaptchas(const Tp::CaptchaAnswers& answers, int timeout = -1)
01266 {
01267 if (!invalidationReason().isEmpty()) {
01268 return QDBusPendingReply<>(QDBusMessage::createError(
01269 invalidationReason(),
01270 invalidationMessage()
01271 ));
01272 }
01273
01274 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01275 this->staticInterfaceName(), QLatin1String("AnswerCaptchas"));
01276 callMessage << QVariant::fromValue(answers);
01277 return this->connection().asyncCall(callMessage, timeout);
01278 }
01279
01307 inline QDBusPendingReply<> CancelCaptcha(uint reason, const QString& debugMessage, int timeout = -1)
01308 {
01309 if (!invalidationReason().isEmpty()) {
01310 return QDBusPendingReply<>(QDBusMessage::createError(
01311 invalidationReason(),
01312 invalidationMessage()
01313 ));
01314 }
01315
01316 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01317 this->staticInterfaceName(), QLatin1String("CancelCaptcha"));
01318 callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
01319 return this->connection().asyncCall(callMessage, timeout);
01320 }
01321
01322 protected:
01323 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01324 };
01325
01333 class TP_QT_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
01334 {
01335 Q_OBJECT
01336
01337 public:
01344 static inline QLatin1String staticInterfaceName()
01345 {
01346 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ChatState");
01347 }
01348
01356 ChannelInterfaceChatStateInterface(
01357 const QString& busName,
01358 const QString& objectPath,
01359 QObject* parent = 0
01360 );
01361
01370 ChannelInterfaceChatStateInterface(
01371 const QDBusConnection& connection,
01372 const QString& busName,
01373 const QString& objectPath,
01374 QObject* parent = 0
01375 );
01376
01383 ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
01384
01392 explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
01393
01401 ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01402
01438 inline Tp::PendingVariant *requestPropertyChatStates() const
01439 {
01440 return internalRequestProperty(QLatin1String("ChatStates"));
01441 }
01442
01449 Tp::PendingVariantMap *requestAllProperties() const
01450 {
01451 return internalRequestAllProperties();
01452 }
01453
01454 public Q_SLOTS:
01470 inline QDBusPendingReply<> SetChatState(uint state, int timeout = -1)
01471 {
01472 if (!invalidationReason().isEmpty()) {
01473 return QDBusPendingReply<>(QDBusMessage::createError(
01474 invalidationReason(),
01475 invalidationMessage()
01476 ));
01477 }
01478
01479 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01480 this->staticInterfaceName(), QLatin1String("SetChatState"));
01481 callMessage << QVariant::fromValue(state);
01482 return this->connection().asyncCall(callMessage, timeout);
01483 }
01484
01485 Q_SIGNALS:
01500 void ChatStateChanged(uint contact, uint state);
01501
01502 protected:
01503 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01504 };
01505
01513 class TP_QT_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
01514 {
01515 Q_OBJECT
01516
01517 public:
01524 static inline QLatin1String staticInterfaceName()
01525 {
01526 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Conference");
01527 }
01528
01536 ChannelInterfaceConferenceInterface(
01537 const QString& busName,
01538 const QString& objectPath,
01539 QObject* parent = 0
01540 );
01541
01550 ChannelInterfaceConferenceInterface(
01551 const QDBusConnection& connection,
01552 const QString& busName,
01553 const QString& objectPath,
01554 QObject* parent = 0
01555 );
01556
01563 ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
01564
01572 explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
01573
01581 ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01582
01611 inline Tp::PendingVariant *requestPropertyChannels() const
01612 {
01613 return internalRequestProperty(QLatin1String("Channels"));
01614 }
01615
01677 inline Tp::PendingVariant *requestPropertyInitialChannels() const
01678 {
01679 return internalRequestProperty(QLatin1String("InitialChannels"));
01680 }
01681
01755 inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
01756 {
01757 return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
01758 }
01759
01784 inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
01785 {
01786 return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
01787 }
01788
01816 inline Tp::PendingVariant *requestPropertyInvitationMessage() const
01817 {
01818 return internalRequestProperty(QLatin1String("InvitationMessage"));
01819 }
01820
01886 inline Tp::PendingVariant *requestPropertyOriginalChannels() const
01887 {
01888 return internalRequestProperty(QLatin1String("OriginalChannels"));
01889 }
01890
01897 Tp::PendingVariantMap *requestAllProperties() const
01898 {
01899 return internalRequestAllProperties();
01900 }
01901
01902 Q_SIGNALS:
01926 void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01927
01952 void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01953
01954 protected:
01955 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01956 };
01957
01965 class TP_QT_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01966 {
01967 Q_OBJECT
01968
01969 public:
01976 static inline QLatin1String staticInterfaceName()
01977 {
01978 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
01979 }
01980
01988 ChannelInterfaceDTMFInterface(
01989 const QString& busName,
01990 const QString& objectPath,
01991 QObject* parent = 0
01992 );
01993
02002 ChannelInterfaceDTMFInterface(
02003 const QDBusConnection& connection,
02004 const QString& busName,
02005 const QString& objectPath,
02006 QObject* parent = 0
02007 );
02008
02015 ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
02016
02024 explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
02025
02033 ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02034
02046 inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
02047 {
02048 return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
02049 }
02050
02064 inline Tp::PendingVariant *requestPropertyInitialTones() const
02065 {
02066 return internalRequestProperty(QLatin1String("InitialTones"));
02067 }
02068
02086 inline Tp::PendingVariant *requestPropertyDeferredTones() const
02087 {
02088 return internalRequestProperty(QLatin1String("DeferredTones"));
02089 }
02090
02097 Tp::PendingVariantMap *requestAllProperties() const
02098 {
02099 return internalRequestAllProperties();
02100 }
02101
02102 public Q_SLOTS:
02133 inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
02134 {
02135 if (!invalidationReason().isEmpty()) {
02136 return QDBusPendingReply<>(QDBusMessage::createError(
02137 invalidationReason(),
02138 invalidationMessage()
02139 ));
02140 }
02141
02142 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02143 this->staticInterfaceName(), QLatin1String("StartTone"));
02144 callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
02145 return this->connection().asyncCall(callMessage, timeout);
02146 }
02147
02170 inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
02171 {
02172 if (!invalidationReason().isEmpty()) {
02173 return QDBusPendingReply<>(QDBusMessage::createError(
02174 invalidationReason(),
02175 invalidationMessage()
02176 ));
02177 }
02178
02179 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02180 this->staticInterfaceName(), QLatin1String("StopTone"));
02181 callMessage << QVariant::fromValue(streamID);
02182 return this->connection().asyncCall(callMessage, timeout);
02183 }
02184
02230 inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
02231 {
02232 if (!invalidationReason().isEmpty()) {
02233 return QDBusPendingReply<>(QDBusMessage::createError(
02234 invalidationReason(),
02235 invalidationMessage()
02236 ));
02237 }
02238
02239 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02240 this->staticInterfaceName(), QLatin1String("MultipleTones"));
02241 callMessage << QVariant::fromValue(tones);
02242 return this->connection().asyncCall(callMessage, timeout);
02243 }
02244
02245 Q_SIGNALS:
02273 void TonesDeferred(const QString& tones);
02274
02291 void SendingTones(const QString& tones);
02292
02304 void StoppedTones(bool cancelled);
02305
02306 protected:
02307 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02308 };
02309
02317 class TP_QT_EXPORT ChannelInterfaceDestroyableInterface : public Tp::AbstractInterface
02318 {
02319 Q_OBJECT
02320
02321 public:
02328 static inline QLatin1String staticInterfaceName()
02329 {
02330 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Destroyable");
02331 }
02332
02340 ChannelInterfaceDestroyableInterface(
02341 const QString& busName,
02342 const QString& objectPath,
02343 QObject* parent = 0
02344 );
02345
02354 ChannelInterfaceDestroyableInterface(
02355 const QDBusConnection& connection,
02356 const QString& busName,
02357 const QString& objectPath,
02358 QObject* parent = 0
02359 );
02360
02367 ChannelInterfaceDestroyableInterface(Tp::DBusProxy *proxy);
02368
02376 explicit ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface);
02377
02385 ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02386
02393 Tp::PendingVariantMap *requestAllProperties() const
02394 {
02395 return internalRequestAllProperties();
02396 }
02397
02398 public Q_SLOTS:
02443 inline QDBusPendingReply<> Destroy(int timeout = -1)
02444 {
02445 if (!invalidationReason().isEmpty()) {
02446 return QDBusPendingReply<>(QDBusMessage::createError(
02447 invalidationReason(),
02448 invalidationMessage()
02449 ));
02450 }
02451
02452 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02453 this->staticInterfaceName(), QLatin1String("Destroy"));
02454 return this->connection().asyncCall(callMessage, timeout);
02455 }
02456
02457 protected:
02458 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02459 };
02460
02468 class TP_QT_EXPORT ChannelInterfaceFileTransferMetadataInterface : public Tp::AbstractInterface
02469 {
02470 Q_OBJECT
02471
02472 public:
02479 static inline QLatin1String staticInterfaceName()
02480 {
02481 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.FileTransfer.Metadata");
02482 }
02483
02491 ChannelInterfaceFileTransferMetadataInterface(
02492 const QString& busName,
02493 const QString& objectPath,
02494 QObject* parent = 0
02495 );
02496
02505 ChannelInterfaceFileTransferMetadataInterface(
02506 const QDBusConnection& connection,
02507 const QString& busName,
02508 const QString& objectPath,
02509 QObject* parent = 0
02510 );
02511
02518 ChannelInterfaceFileTransferMetadataInterface(Tp::DBusProxy *proxy);
02519
02527 explicit ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface);
02528
02536 ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02537
02554 inline Tp::PendingVariant *requestPropertyServiceName() const
02555 {
02556 return internalRequestProperty(QLatin1String("ServiceName"));
02557 }
02558
02575 inline Tp::PendingOperation *setPropertyServiceName(QString newValue)
02576 {
02577 return internalSetProperty(QLatin1String("ServiceName"), QVariant::fromValue(newValue));
02578 }
02579
02593 inline Tp::PendingVariant *requestPropertyMetadata() const
02594 {
02595 return internalRequestProperty(QLatin1String("Metadata"));
02596 }
02597
02611 inline Tp::PendingOperation *setPropertyMetadata(Tp::Metadata newValue)
02612 {
02613 return internalSetProperty(QLatin1String("Metadata"), QVariant::fromValue(newValue));
02614 }
02615
02622 Tp::PendingVariantMap *requestAllProperties() const
02623 {
02624 return internalRequestAllProperties();
02625 }
02626
02627 protected:
02628 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02629 };
02630
02638 class TP_QT_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
02639 {
02640 Q_OBJECT
02641
02642 public:
02649 static inline QLatin1String staticInterfaceName()
02650 {
02651 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
02652 }
02653
02661 ChannelInterfaceGroupInterface(
02662 const QString& busName,
02663 const QString& objectPath,
02664 QObject* parent = 0
02665 );
02666
02675 ChannelInterfaceGroupInterface(
02676 const QDBusConnection& connection,
02677 const QString& busName,
02678 const QString& objectPath,
02679 QObject* parent = 0
02680 );
02681
02688 ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
02689
02697 explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
02698
02706 ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02707
02720 inline Tp::PendingVariant *requestPropertyGroupFlags() const
02721 {
02722 return internalRequestProperty(QLatin1String("GroupFlags"));
02723 }
02724
02740 inline Tp::PendingVariant *requestPropertyHandleOwners() const
02741 {
02742 return internalRequestProperty(QLatin1String("HandleOwners"));
02743 }
02744
02755 inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
02756 {
02757 return internalRequestProperty(QLatin1String("LocalPendingMembers"));
02758 }
02759
02769 inline Tp::PendingVariant *requestPropertyMembers() const
02770 {
02771 return internalRequestProperty(QLatin1String("Members"));
02772 }
02773
02784 inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
02785 {
02786 return internalRequestProperty(QLatin1String("RemotePendingMembers"));
02787 }
02788
02803 inline Tp::PendingVariant *requestPropertySelfHandle() const
02804 {
02805 return internalRequestProperty(QLatin1String("SelfHandle"));
02806 }
02807
02821 inline Tp::PendingVariant *requestPropertyMemberIdentifiers() const
02822 {
02823 return internalRequestProperty(QLatin1String("MemberIdentifiers"));
02824 }
02825
02832 Tp::PendingVariantMap *requestAllProperties() const
02833 {
02834 return internalRequestAllProperties();
02835 }
02836
02837 public Q_SLOTS:
02868 inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02869 {
02870 if (!invalidationReason().isEmpty()) {
02871 return QDBusPendingReply<>(QDBusMessage::createError(
02872 invalidationReason(),
02873 invalidationMessage()
02874 ));
02875 }
02876
02877 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02878 this->staticInterfaceName(), QLatin1String("AddMembers"));
02879 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02880 return this->connection().asyncCall(callMessage, timeout);
02881 }
02882
02905 inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
02906 {
02907 if (!invalidationReason().isEmpty()) {
02908 return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02909 invalidationReason(),
02910 invalidationMessage()
02911 ));
02912 }
02913
02914 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02915 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
02916 return this->connection().asyncCall(callMessage, timeout);
02917 }
02918
02933 inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
02934 {
02935 if (!invalidationReason().isEmpty()) {
02936 return QDBusPendingReply<uint>(QDBusMessage::createError(
02937 invalidationReason(),
02938 invalidationMessage()
02939 ));
02940 }
02941
02942 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02943 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
02944 return this->connection().asyncCall(callMessage, timeout);
02945 }
02946
02972 inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
02973 {
02974 if (!invalidationReason().isEmpty()) {
02975 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02976 invalidationReason(),
02977 invalidationMessage()
02978 ));
02979 }
02980
02981 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02982 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
02983 callMessage << QVariant::fromValue(handles);
02984 return this->connection().asyncCall(callMessage, timeout);
02985 }
02986
02998 inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
02999 {
03000 if (!invalidationReason().isEmpty()) {
03001 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
03002 invalidationReason(),
03003 invalidationMessage()
03004 ));
03005 }
03006
03007 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03008 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
03009 return this->connection().asyncCall(callMessage, timeout);
03010 }
03011
03030 inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
03031 {
03032 if (!invalidationReason().isEmpty()) {
03033 return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
03034 invalidationReason(),
03035 invalidationMessage()
03036 ));
03037 }
03038
03039 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03040 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
03041 return this->connection().asyncCall(callMessage, timeout);
03042 }
03043
03054 inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
03055 {
03056 if (!invalidationReason().isEmpty()) {
03057 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
03058 invalidationReason(),
03059 invalidationMessage()
03060 ));
03061 }
03062
03063 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03064 this->staticInterfaceName(), QLatin1String("GetMembers"));
03065 return this->connection().asyncCall(callMessage, timeout);
03066 }
03067
03079 inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
03080 {
03081 if (!invalidationReason().isEmpty()) {
03082 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
03083 invalidationReason(),
03084 invalidationMessage()
03085 ));
03086 }
03087
03088 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03089 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
03090 return this->connection().asyncCall(callMessage, timeout);
03091 }
03092
03103 inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
03104 {
03105 if (!invalidationReason().isEmpty()) {
03106 return QDBusPendingReply<uint>(QDBusMessage::createError(
03107 invalidationReason(),
03108 invalidationMessage()
03109 ));
03110 }
03111
03112 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03113 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
03114 return this->connection().asyncCall(callMessage, timeout);
03115 }
03116
03172 inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
03173 {
03174 if (!invalidationReason().isEmpty()) {
03175 return QDBusPendingReply<>(QDBusMessage::createError(
03176 invalidationReason(),
03177 invalidationMessage()
03178 ));
03179 }
03180
03181 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03182 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
03183 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
03184 return this->connection().asyncCall(callMessage, timeout);
03185 }
03186
03211 inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
03212 {
03213 if (!invalidationReason().isEmpty()) {
03214 return QDBusPendingReply<>(QDBusMessage::createError(
03215 invalidationReason(),
03216 invalidationMessage()
03217 ));
03218 }
03219
03220 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03221 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
03222 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
03223 return this->connection().asyncCall(callMessage, timeout);
03224 }
03225
03226 Q_SIGNALS:
03245 void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
03246
03275 void HandleOwnersChangedDetailed(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed, const Tp::HandleIdentifierMap& identifiers);
03276
03286 void SelfHandleChanged(uint selfHandle);
03287
03303 void SelfContactChanged(uint selfHandle, const QString& selfID);
03304
03319 void GroupFlagsChanged(uint added, uint removed);
03320
03374 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);
03375
03484 void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
03485
03486 protected:
03487 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03488 };
03489
03497 class TP_QT_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
03498 {
03499 Q_OBJECT
03500
03501 public:
03508 static inline QLatin1String staticInterfaceName()
03509 {
03510 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
03511 }
03512
03520 ChannelInterfaceHoldInterface(
03521 const QString& busName,
03522 const QString& objectPath,
03523 QObject* parent = 0
03524 );
03525
03534 ChannelInterfaceHoldInterface(
03535 const QDBusConnection& connection,
03536 const QString& busName,
03537 const QString& objectPath,
03538 QObject* parent = 0
03539 );
03540
03547 ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
03548
03556 explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
03557
03565 ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03566
03573 Tp::PendingVariantMap *requestAllProperties() const
03574 {
03575 return internalRequestAllProperties();
03576 }
03577
03578 public Q_SLOTS:
03597 inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
03598 {
03599 if (!invalidationReason().isEmpty()) {
03600 return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
03601 invalidationReason(),
03602 invalidationMessage()
03603 ));
03604 }
03605
03606 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03607 this->staticInterfaceName(), QLatin1String("GetHoldState"));
03608 return this->connection().asyncCall(callMessage, timeout);
03609 }
03610
03674 inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
03675 {
03676 if (!invalidationReason().isEmpty()) {
03677 return QDBusPendingReply<>(QDBusMessage::createError(
03678 invalidationReason(),
03679 invalidationMessage()
03680 ));
03681 }
03682
03683 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03684 this->staticInterfaceName(), QLatin1String("RequestHold"));
03685 callMessage << QVariant::fromValue(hold);
03686 return this->connection().asyncCall(callMessage, timeout);
03687 }
03688
03689 Q_SIGNALS:
03706 void HoldStateChanged(uint holdState, uint reason);
03707
03708 protected:
03709 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03710 };
03711
03719 class TP_QT_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
03720 {
03721 Q_OBJECT
03722
03723 public:
03730 static inline QLatin1String staticInterfaceName()
03731 {
03732 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
03733 }
03734
03742 ChannelInterfaceMediaSignallingInterface(
03743 const QString& busName,
03744 const QString& objectPath,
03745 QObject* parent = 0
03746 );
03747
03756 ChannelInterfaceMediaSignallingInterface(
03757 const QDBusConnection& connection,
03758 const QString& busName,
03759 const QString& objectPath,
03760 QObject* parent = 0
03761 );
03762
03769 ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
03770
03778 explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
03779
03787 ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03788
03795 Tp::PendingVariantMap *requestAllProperties() const
03796 {
03797 return internalRequestAllProperties();
03798 }
03799
03800 public Q_SLOTS:
03812 inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
03813 {
03814 if (!invalidationReason().isEmpty()) {
03815 return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
03816 invalidationReason(),
03817 invalidationMessage()
03818 ));
03819 }
03820
03821 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03822 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
03823 return this->connection().asyncCall(callMessage, timeout);
03824 }
03825
03826 Q_SIGNALS:
03842 void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
03843
03844 protected:
03845 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03846 };
03847
03855 class TP_QT_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
03856 {
03857 Q_OBJECT
03858
03859 public:
03866 static inline QLatin1String staticInterfaceName()
03867 {
03868 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
03869 }
03870
03878 ChannelInterfaceMessagesInterface(
03879 const QString& busName,
03880 const QString& objectPath,
03881 QObject* parent = 0
03882 );
03883
03892 ChannelInterfaceMessagesInterface(
03893 const QDBusConnection& connection,
03894 const QString& busName,
03895 const QString& objectPath,
03896 QObject* parent = 0
03897 );
03898
03905 ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
03906
03914 explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
03915
03923 ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03924
03978 inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
03979 {
03980 return internalRequestProperty(QLatin1String("SupportedContentTypes"));
03981 }
03982
03994 inline Tp::PendingVariant *requestPropertyMessageTypes() const
03995 {
03996 return internalRequestProperty(QLatin1String("MessageTypes"));
03997 }
03998
04008 inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
04009 {
04010 return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
04011 }
04012
04033 inline Tp::PendingVariant *requestPropertyPendingMessages() const
04034 {
04035 return internalRequestProperty(QLatin1String("PendingMessages"));
04036 }
04037
04047 inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
04048 {
04049 return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
04050 }
04051
04058 Tp::PendingVariantMap *requestAllProperties() const
04059 {
04060 return internalRequestAllProperties();
04061 }
04062
04063 public Q_SLOTS:
04126 inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
04127 {
04128 if (!invalidationReason().isEmpty()) {
04129 return QDBusPendingReply<QString>(QDBusMessage::createError(
04130 invalidationReason(),
04131 invalidationMessage()
04132 ));
04133 }
04134
04135 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04136 this->staticInterfaceName(), QLatin1String("SendMessage"));
04137 callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
04138 return this->connection().asyncCall(callMessage, timeout);
04139 }
04140
04181 inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
04182 {
04183 if (!invalidationReason().isEmpty()) {
04184 return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
04185 invalidationReason(),
04186 invalidationMessage()
04187 ));
04188 }
04189
04190 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04191 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
04192 callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
04193 return this->connection().asyncCall(callMessage, timeout);
04194 }
04195
04196 Q_SIGNALS:
04256 void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
04257
04271 void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
04272
04293 void MessageReceived(const Tp::MessagePartList& message);
04294
04295 protected:
04296 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04297 };
04298
04306 class TP_QT_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
04307 {
04308 Q_OBJECT
04309
04310 public:
04317 static inline QLatin1String staticInterfaceName()
04318 {
04319 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
04320 }
04321
04329 ChannelInterfacePasswordInterface(
04330 const QString& busName,
04331 const QString& objectPath,
04332 QObject* parent = 0
04333 );
04334
04343 ChannelInterfacePasswordInterface(
04344 const QDBusConnection& connection,
04345 const QString& busName,
04346 const QString& objectPath,
04347 QObject* parent = 0
04348 );
04349
04356 ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
04357
04365 explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
04366
04374 ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04375
04382 Tp::PendingVariantMap *requestAllProperties() const
04383 {
04384 return internalRequestAllProperties();
04385 }
04386
04387 public Q_SLOTS:
04405 inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
04406 {
04407 if (!invalidationReason().isEmpty()) {
04408 return QDBusPendingReply<uint>(QDBusMessage::createError(
04409 invalidationReason(),
04410 invalidationMessage()
04411 ));
04412 }
04413
04414 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04415 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
04416 return this->connection().asyncCall(callMessage, timeout);
04417 }
04418
04439 inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
04440 {
04441 if (!invalidationReason().isEmpty()) {
04442 return QDBusPendingReply<bool>(QDBusMessage::createError(
04443 invalidationReason(),
04444 invalidationMessage()
04445 ));
04446 }
04447
04448 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04449 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
04450 callMessage << QVariant::fromValue(password);
04451 return this->connection().asyncCall(callMessage, timeout);
04452 }
04453
04454 Q_SIGNALS:
04469 void PasswordFlagsChanged(uint added, uint removed);
04470
04471 protected:
04472 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04473 };
04474
04482 class TP_QT_EXPORT ChannelInterfaceRoomConfigInterface : public Tp::AbstractInterface
04483 {
04484 Q_OBJECT
04485
04486 public:
04493 static inline QLatin1String staticInterfaceName()
04494 {
04495 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.RoomConfig1");
04496 }
04497
04505 ChannelInterfaceRoomConfigInterface(
04506 const QString& busName,
04507 const QString& objectPath,
04508 QObject* parent = 0
04509 );
04510
04519 ChannelInterfaceRoomConfigInterface(
04520 const QDBusConnection& connection,
04521 const QString& busName,
04522 const QString& objectPath,
04523 QObject* parent = 0
04524 );
04525
04532 ChannelInterfaceRoomConfigInterface(Tp::DBusProxy *proxy);
04533
04541 explicit ChannelInterfaceRoomConfigInterface(const Tp::Client::ChannelInterface& mainInterface);
04542
04550 ChannelInterfaceRoomConfigInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04551
04562 inline Tp::PendingVariant *requestPropertyAnonymous() const
04563 {
04564 return internalRequestProperty(QLatin1String("Anonymous"));
04565 }
04566
04576 inline Tp::PendingVariant *requestPropertyInviteOnly() const
04577 {
04578 return internalRequestProperty(QLatin1String("InviteOnly"));
04579 }
04580
04590 inline Tp::PendingVariant *requestPropertyLimit() const
04591 {
04592 return internalRequestProperty(QLatin1String("Limit"));
04593 }
04594
04604 inline Tp::PendingVariant *requestPropertyModerated() const
04605 {
04606 return internalRequestProperty(QLatin1String("Moderated"));
04607 }
04608
04638 inline Tp::PendingVariant *requestPropertyTitle() const
04639 {
04640 return internalRequestProperty(QLatin1String("Title"));
04641 }
04642
04653 inline Tp::PendingVariant *requestPropertyDescription() const
04654 {
04655 return internalRequestProperty(QLatin1String("Description"));
04656 }
04657
04670 inline Tp::PendingVariant *requestPropertyPersistent() const
04671 {
04672 return internalRequestProperty(QLatin1String("Persistent"));
04673 }
04674
04686 inline Tp::PendingVariant *requestPropertyPrivate() const
04687 {
04688 return internalRequestProperty(QLatin1String("Private"));
04689 }
04690
04706 inline Tp::PendingVariant *requestPropertyPasswordProtected() const
04707 {
04708 return internalRequestProperty(QLatin1String("PasswordProtected"));
04709 }
04710
04732 inline Tp::PendingVariant *requestPropertyPassword() const
04733 {
04734 return internalRequestProperty(QLatin1String("Password"));
04735 }
04736
04759 inline Tp::PendingVariant *requestPropertyPasswordHint() const
04760 {
04761 return internalRequestProperty(QLatin1String("PasswordHint"));
04762 }
04763
04778 inline Tp::PendingVariant *requestPropertyCanUpdateConfiguration() const
04779 {
04780 return internalRequestProperty(QLatin1String("CanUpdateConfiguration"));
04781 }
04782
04805 inline Tp::PendingVariant *requestPropertyMutableProperties() const
04806 {
04807 return internalRequestProperty(QLatin1String("MutableProperties"));
04808 }
04809
04834 inline Tp::PendingVariant *requestPropertyConfigurationRetrieved() const
04835 {
04836 return internalRequestProperty(QLatin1String("ConfigurationRetrieved"));
04837 }
04838
04845 Tp::PendingVariantMap *requestAllProperties() const
04846 {
04847 return internalRequestAllProperties();
04848 }
04849
04850 public Q_SLOTS:
04893 inline QDBusPendingReply<> UpdateConfiguration(const QVariantMap& properties, int timeout = -1)
04894 {
04895 if (!invalidationReason().isEmpty()) {
04896 return QDBusPendingReply<>(QDBusMessage::createError(
04897 invalidationReason(),
04898 invalidationMessage()
04899 ));
04900 }
04901
04902 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04903 this->staticInterfaceName(), QLatin1String("UpdateConfiguration"));
04904 callMessage << QVariant::fromValue(properties);
04905 return this->connection().asyncCall(callMessage, timeout);
04906 }
04907
04908 protected:
04909 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04910 };
04911
04919 class TP_QT_EXPORT ChannelInterfaceRoomInterface : public Tp::AbstractInterface
04920 {
04921 Q_OBJECT
04922
04923 public:
04930 static inline QLatin1String staticInterfaceName()
04931 {
04932 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Room2");
04933 }
04934
04942 ChannelInterfaceRoomInterface(
04943 const QString& busName,
04944 const QString& objectPath,
04945 QObject* parent = 0
04946 );
04947
04956 ChannelInterfaceRoomInterface(
04957 const QDBusConnection& connection,
04958 const QString& busName,
04959 const QString& objectPath,
04960 QObject* parent = 0
04961 );
04962
04969 ChannelInterfaceRoomInterface(Tp::DBusProxy *proxy);
04970
04978 explicit ChannelInterfaceRoomInterface(const Tp::Client::ChannelInterface& mainInterface);
04979
04987 ChannelInterfaceRoomInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04988
05014 inline Tp::PendingVariant *requestPropertyRoomName() const
05015 {
05016 return internalRequestProperty(QLatin1String("RoomName"));
05017 }
05018
05039 inline Tp::PendingVariant *requestPropertyServer() const
05040 {
05041 return internalRequestProperty(QLatin1String("Server"));
05042 }
05043
05056 inline Tp::PendingVariant *requestPropertyCreator() const
05057 {
05058 return internalRequestProperty(QLatin1String("Creator"));
05059 }
05060
05073 inline Tp::PendingVariant *requestPropertyCreatorHandle() const
05074 {
05075 return internalRequestProperty(QLatin1String("CreatorHandle"));
05076 }
05077
05090 inline Tp::PendingVariant *requestPropertyCreationTimestamp() const
05091 {
05092 return internalRequestProperty(QLatin1String("CreationTimestamp"));
05093 }
05094
05101 Tp::PendingVariantMap *requestAllProperties() const
05102 {
05103 return internalRequestAllProperties();
05104 }
05105
05106 protected:
05107 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05108 };
05109
05117 class TP_QT_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
05118 {
05119 Q_OBJECT
05120
05121 public:
05128 static inline QLatin1String staticInterfaceName()
05129 {
05130 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
05131 }
05132
05140 ChannelInterfaceSASLAuthenticationInterface(
05141 const QString& busName,
05142 const QString& objectPath,
05143 QObject* parent = 0
05144 );
05145
05154 ChannelInterfaceSASLAuthenticationInterface(
05155 const QDBusConnection& connection,
05156 const QString& busName,
05157 const QString& objectPath,
05158 QObject* parent = 0
05159 );
05160
05167 ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
05168
05176 explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
05177
05185 ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05186
05209 inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
05210 {
05211 return internalRequestProperty(QLatin1String("AvailableMechanisms"));
05212 }
05213
05235 inline Tp::PendingVariant *requestPropertyHasInitialData() const
05236 {
05237 return internalRequestProperty(QLatin1String("HasInitialData"));
05238 }
05239
05260 inline Tp::PendingVariant *requestPropertyCanTryAgain() const
05261 {
05262 return internalRequestProperty(QLatin1String("CanTryAgain"));
05263 }
05264
05278 inline Tp::PendingVariant *requestPropertySASLStatus() const
05279 {
05280 return internalRequestProperty(QLatin1String("SASLStatus"));
05281 }
05282
05311 inline Tp::PendingVariant *requestPropertySASLError() const
05312 {
05313 return internalRequestProperty(QLatin1String("SASLError"));
05314 }
05315
05337 inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
05338 {
05339 return internalRequestProperty(QLatin1String("SASLErrorDetails"));
05340 }
05341
05406 inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
05407 {
05408 return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
05409 }
05410
05472 inline Tp::PendingVariant *requestPropertyDefaultUsername() const
05473 {
05474 return internalRequestProperty(QLatin1String("DefaultUsername"));
05475 }
05476
05504 inline Tp::PendingVariant *requestPropertyDefaultRealm() const
05505 {
05506 return internalRequestProperty(QLatin1String("DefaultRealm"));
05507 }
05508
05530 inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
05531 {
05532 return internalRequestProperty(QLatin1String("MaySaveResponse"));
05533 }
05534
05541 Tp::PendingVariantMap *requestAllProperties() const
05542 {
05543 return internalRequestAllProperties();
05544 }
05545
05546 public Q_SLOTS:
05573 inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
05574 {
05575 if (!invalidationReason().isEmpty()) {
05576 return QDBusPendingReply<>(QDBusMessage::createError(
05577 invalidationReason(),
05578 invalidationMessage()
05579 ));
05580 }
05581
05582 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05583 this->staticInterfaceName(), QLatin1String("StartMechanism"));
05584 callMessage << QVariant::fromValue(mechanism);
05585 return this->connection().asyncCall(callMessage, timeout);
05586 }
05587
05642 inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
05643 {
05644 if (!invalidationReason().isEmpty()) {
05645 return QDBusPendingReply<>(QDBusMessage::createError(
05646 invalidationReason(),
05647 invalidationMessage()
05648 ));
05649 }
05650
05651 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05652 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
05653 callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
05654 return this->connection().asyncCall(callMessage, timeout);
05655 }
05656
05674 inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
05675 {
05676 if (!invalidationReason().isEmpty()) {
05677 return QDBusPendingReply<>(QDBusMessage::createError(
05678 invalidationReason(),
05679 invalidationMessage()
05680 ));
05681 }
05682
05683 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05684 this->staticInterfaceName(), QLatin1String("Respond"));
05685 callMessage << QVariant::fromValue(responseData);
05686 return this->connection().asyncCall(callMessage, timeout);
05687 }
05688
05717 inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
05718 {
05719 if (!invalidationReason().isEmpty()) {
05720 return QDBusPendingReply<>(QDBusMessage::createError(
05721 invalidationReason(),
05722 invalidationMessage()
05723 ));
05724 }
05725
05726 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05727 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
05728 return this->connection().asyncCall(callMessage, timeout);
05729 }
05730
05759 inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
05760 {
05761 if (!invalidationReason().isEmpty()) {
05762 return QDBusPendingReply<>(QDBusMessage::createError(
05763 invalidationReason(),
05764 invalidationMessage()
05765 ));
05766 }
05767
05768 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05769 this->staticInterfaceName(), QLatin1String("AbortSASL"));
05770 callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
05771 return this->connection().asyncCall(callMessage, timeout);
05772 }
05773
05774 Q_SIGNALS:
05792 void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
05793
05813 void NewChallenge(const QByteArray& challengeData);
05814
05815 protected:
05816 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05817 };
05818
05826 class TP_QT_EXPORT ChannelInterfaceSMSInterface : public Tp::AbstractInterface
05827 {
05828 Q_OBJECT
05829
05830 public:
05837 static inline QLatin1String staticInterfaceName()
05838 {
05839 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SMS");
05840 }
05841
05849 ChannelInterfaceSMSInterface(
05850 const QString& busName,
05851 const QString& objectPath,
05852 QObject* parent = 0
05853 );
05854
05863 ChannelInterfaceSMSInterface(
05864 const QDBusConnection& connection,
05865 const QString& busName,
05866 const QString& objectPath,
05867 QObject* parent = 0
05868 );
05869
05876 ChannelInterfaceSMSInterface(Tp::DBusProxy *proxy);
05877
05885 explicit ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface);
05886
05894 ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05895
05935 inline Tp::PendingVariant *requestPropertyFlash() const
05936 {
05937 return internalRequestProperty(QLatin1String("Flash"));
05938 }
05939
06002 inline Tp::PendingVariant *requestPropertySMSChannel() const
06003 {
06004 return internalRequestProperty(QLatin1String("SMSChannel"));
06005 }
06006
06013 Tp::PendingVariantMap *requestAllProperties() const
06014 {
06015 return internalRequestAllProperties();
06016 }
06017
06018 public Q_SLOTS:
06083 inline QDBusPendingReply<uint, int, int> GetSMSLength(const Tp::MessagePartList& message, int timeout = -1)
06084 {
06085 if (!invalidationReason().isEmpty()) {
06086 return QDBusPendingReply<uint, int, int>(QDBusMessage::createError(
06087 invalidationReason(),
06088 invalidationMessage()
06089 ));
06090 }
06091
06092 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06093 this->staticInterfaceName(), QLatin1String("GetSMSLength"));
06094 callMessage << QVariant::fromValue(message);
06095 return this->connection().asyncCall(callMessage, timeout);
06096 }
06097
06098 Q_SIGNALS:
06108 void SMSChannelChanged(bool SMSChannel);
06109
06110 protected:
06111 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06112 };
06113
06121 class TP_QT_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
06122 {
06123 Q_OBJECT
06124
06125 public:
06132 static inline QLatin1String staticInterfaceName()
06133 {
06134 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
06135 }
06136
06144 ChannelInterfaceSecurableInterface(
06145 const QString& busName,
06146 const QString& objectPath,
06147 QObject* parent = 0
06148 );
06149
06158 ChannelInterfaceSecurableInterface(
06159 const QDBusConnection& connection,
06160 const QString& busName,
06161 const QString& objectPath,
06162 QObject* parent = 0
06163 );
06164
06171 ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
06172
06180 explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
06181
06189 ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06190
06212 inline Tp::PendingVariant *requestPropertyEncrypted() const
06213 {
06214 return internalRequestProperty(QLatin1String("Encrypted"));
06215 }
06216
06233 inline Tp::PendingVariant *requestPropertyVerified() const
06234 {
06235 return internalRequestProperty(QLatin1String("Verified"));
06236 }
06237
06244 Tp::PendingVariantMap *requestAllProperties() const
06245 {
06246 return internalRequestAllProperties();
06247 }
06248
06249 protected:
06250 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06251 };
06252
06260 class TP_QT_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
06261 {
06262 Q_OBJECT
06263
06264 public:
06271 static inline QLatin1String staticInterfaceName()
06272 {
06273 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
06274 }
06275
06283 ChannelInterfaceServicePointInterface(
06284 const QString& busName,
06285 const QString& objectPath,
06286 QObject* parent = 0
06287 );
06288
06297 ChannelInterfaceServicePointInterface(
06298 const QDBusConnection& connection,
06299 const QString& busName,
06300 const QString& objectPath,
06301 QObject* parent = 0
06302 );
06303
06310 ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
06311
06319 explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
06320
06328 ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06329
06349 inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
06350 {
06351 return internalRequestProperty(QLatin1String("InitialServicePoint"));
06352 }
06353
06366 inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
06367 {
06368 return internalRequestProperty(QLatin1String("CurrentServicePoint"));
06369 }
06370
06377 Tp::PendingVariantMap *requestAllProperties() const
06378 {
06379 return internalRequestAllProperties();
06380 }
06381
06382 Q_SIGNALS:
06399 void ServicePointChanged(const Tp::ServicePoint& servicePoint);
06400
06401 protected:
06402 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06403 };
06404
06412 class TP_QT_EXPORT ChannelInterfaceSubjectInterface : public Tp::AbstractInterface
06413 {
06414 Q_OBJECT
06415
06416 public:
06423 static inline QLatin1String staticInterfaceName()
06424 {
06425 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Subject2");
06426 }
06427
06435 ChannelInterfaceSubjectInterface(
06436 const QString& busName,
06437 const QString& objectPath,
06438 QObject* parent = 0
06439 );
06440
06449 ChannelInterfaceSubjectInterface(
06450 const QDBusConnection& connection,
06451 const QString& busName,
06452 const QString& objectPath,
06453 QObject* parent = 0
06454 );
06455
06462 ChannelInterfaceSubjectInterface(Tp::DBusProxy *proxy);
06463
06471 explicit ChannelInterfaceSubjectInterface(const Tp::Client::ChannelInterface& mainInterface);
06472
06480 ChannelInterfaceSubjectInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06481
06501 inline Tp::PendingVariant *requestPropertySubject() const
06502 {
06503 return internalRequestProperty(QLatin1String("Subject"));
06504 }
06505
06522 inline Tp::PendingVariant *requestPropertyActor() const
06523 {
06524 return internalRequestProperty(QLatin1String("Actor"));
06525 }
06526
06539 inline Tp::PendingVariant *requestPropertyActorHandle() const
06540 {
06541 return internalRequestProperty(QLatin1String("ActorHandle"));
06542 }
06543
06560 inline Tp::PendingVariant *requestPropertyTimestamp() const
06561 {
06562 return internalRequestProperty(QLatin1String("Timestamp"));
06563 }
06564
06589 inline Tp::PendingVariant *requestPropertyCanSet() const
06590 {
06591 return internalRequestProperty(QLatin1String("CanSet"));
06592 }
06593
06600 Tp::PendingVariantMap *requestAllProperties() const
06601 {
06602 return internalRequestAllProperties();
06603 }
06604
06605 public Q_SLOTS:
06629 inline QDBusPendingReply<> SetSubject(const QString& subject, int timeout = -1)
06630 {
06631 if (!invalidationReason().isEmpty()) {
06632 return QDBusPendingReply<>(QDBusMessage::createError(
06633 invalidationReason(),
06634 invalidationMessage()
06635 ));
06636 }
06637
06638 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06639 this->staticInterfaceName(), QLatin1String("SetSubject"));
06640 callMessage << QVariant::fromValue(subject);
06641 return this->connection().asyncCall(callMessage, timeout);
06642 }
06643
06644 protected:
06645 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06646 };
06647
06655 class TP_QT_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
06656 {
06657 Q_OBJECT
06658
06659 public:
06666 static inline QLatin1String staticInterfaceName()
06667 {
06668 return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
06669 }
06670
06678 ChannelInterfaceTubeInterface(
06679 const QString& busName,
06680 const QString& objectPath,
06681 QObject* parent = 0
06682 );
06683
06692 ChannelInterfaceTubeInterface(
06693 const QDBusConnection& connection,
06694 const QString& busName,
06695 const QString& objectPath,
06696 QObject* parent = 0
06697 );
06698
06705 ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
06706
06714 explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
06715
06723 ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06724
06770 inline Tp::PendingVariant *requestPropertyParameters() const
06771 {
06772 return internalRequestProperty(QLatin1String("Parameters"));
06773 }
06774
06790 inline Tp::PendingVariant *requestPropertyState() const
06791 {
06792 return internalRequestProperty(QLatin1String("State"));
06793 }
06794
06801 Tp::PendingVariantMap *requestAllProperties() const
06802 {
06803 return internalRequestAllProperties();
06804 }
06805
06806 Q_SIGNALS:
06817 void TubeChannelStateChanged(uint state);
06818
06819 protected:
06820 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06821 };
06822
06830 class TP_QT_EXPORT ChannelTypeCallInterface : public Tp::AbstractInterface
06831 {
06832 Q_OBJECT
06833
06834 public:
06841 static inline QLatin1String staticInterfaceName()
06842 {
06843 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Call1");
06844 }
06845
06853 ChannelTypeCallInterface(
06854 const QString& busName,
06855 const QString& objectPath,
06856 QObject* parent = 0
06857 );
06858
06867 ChannelTypeCallInterface(
06868 const QDBusConnection& connection,
06869 const QString& busName,
06870 const QString& objectPath,
06871 QObject* parent = 0
06872 );
06873
06880 ChannelTypeCallInterface(Tp::DBusProxy *proxy);
06881
06889 explicit ChannelTypeCallInterface(const Tp::Client::ChannelInterface& mainInterface);
06890
06898 ChannelTypeCallInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06899
06915 inline Tp::PendingVariant *requestPropertyContents() const
06916 {
06917 return internalRequestProperty(QLatin1String("Contents"));
06918 }
06919
06983 inline Tp::PendingVariant *requestPropertyCallStateDetails() const
06984 {
06985 return internalRequestProperty(QLatin1String("CallStateDetails"));
06986 }
06987
07012 inline Tp::PendingVariant *requestPropertyCallState() const
07013 {
07014 return internalRequestProperty(QLatin1String("CallState"));
07015 }
07016
07036 inline Tp::PendingVariant *requestPropertyCallFlags() const
07037 {
07038 return internalRequestProperty(QLatin1String("CallFlags"));
07039 }
07040
07056 inline Tp::PendingVariant *requestPropertyCallStateReason() const
07057 {
07058 return internalRequestProperty(QLatin1String("CallStateReason"));
07059 }
07060
07094 inline Tp::PendingVariant *requestPropertyHardwareStreaming() const
07095 {
07096 return internalRequestProperty(QLatin1String("HardwareStreaming"));
07097 }
07098
07124 inline Tp::PendingVariant *requestPropertyCallMembers() const
07125 {
07126 return internalRequestProperty(QLatin1String("CallMembers"));
07127 }
07128
07140 inline Tp::PendingVariant *requestPropertyMemberIdentifiers() const
07141 {
07142 return internalRequestProperty(QLatin1String("MemberIdentifiers"));
07143 }
07144
07166 inline Tp::PendingVariant *requestPropertyInitialTransport() const
07167 {
07168 return internalRequestProperty(QLatin1String("InitialTransport"));
07169 }
07170
07240 inline Tp::PendingVariant *requestPropertyInitialAudio() const
07241 {
07242 return internalRequestProperty(QLatin1String("InitialAudio"));
07243 }
07244
07265 inline Tp::PendingVariant *requestPropertyInitialVideo() const
07266 {
07267 return internalRequestProperty(QLatin1String("InitialVideo"));
07268 }
07269
07297 inline Tp::PendingVariant *requestPropertyInitialAudioName() const
07298 {
07299 return internalRequestProperty(QLatin1String("InitialAudioName"));
07300 }
07301
07317 inline Tp::PendingVariant *requestPropertyInitialVideoName() const
07318 {
07319 return internalRequestProperty(QLatin1String("InitialVideoName"));
07320 }
07321
07353 inline Tp::PendingVariant *requestPropertyMutableContents() const
07354 {
07355 return internalRequestProperty(QLatin1String("MutableContents"));
07356 }
07357
07364 Tp::PendingVariantMap *requestAllProperties() const
07365 {
07366 return internalRequestAllProperties();
07367 }
07368
07369 public Q_SLOTS:
07398 inline QDBusPendingReply<> SetRinging(int timeout = -1)
07399 {
07400 if (!invalidationReason().isEmpty()) {
07401 return QDBusPendingReply<>(QDBusMessage::createError(
07402 invalidationReason(),
07403 invalidationMessage()
07404 ));
07405 }
07406
07407 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07408 this->staticInterfaceName(), QLatin1String("SetRinging"));
07409 return this->connection().asyncCall(callMessage, timeout);
07410 }
07411
07442 inline QDBusPendingReply<> SetQueued(int timeout = -1)
07443 {
07444 if (!invalidationReason().isEmpty()) {
07445 return QDBusPendingReply<>(QDBusMessage::createError(
07446 invalidationReason(),
07447 invalidationMessage()
07448 ));
07449 }
07450
07451 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07452 this->staticInterfaceName(), QLatin1String("SetQueued"));
07453 return this->connection().asyncCall(callMessage, timeout);
07454 }
07455
07490 inline QDBusPendingReply<> Accept(int timeout = -1)
07491 {
07492 if (!invalidationReason().isEmpty()) {
07493 return QDBusPendingReply<>(QDBusMessage::createError(
07494 invalidationReason(),
07495 invalidationMessage()
07496 ));
07497 }
07498
07499 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07500 this->staticInterfaceName(), QLatin1String("Accept"));
07501 return this->connection().asyncCall(callMessage, timeout);
07502 }
07503
07529 inline QDBusPendingReply<> Hangup(uint reason, const QString& detailedHangupReason, const QString& message, int timeout = -1)
07530 {
07531 if (!invalidationReason().isEmpty()) {
07532 return QDBusPendingReply<>(QDBusMessage::createError(
07533 invalidationReason(),
07534 invalidationMessage()
07535 ));
07536 }
07537
07538 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07539 this->staticInterfaceName(), QLatin1String("Hangup"));
07540 callMessage << QVariant::fromValue(reason) << QVariant::fromValue(detailedHangupReason) << QVariant::fromValue(message);
07541 return this->connection().asyncCall(callMessage, timeout);
07542 }
07543
07582 inline QDBusPendingReply<QDBusObjectPath> AddContent(const QString& contentName, uint contentType, uint initialDirection, int timeout = -1)
07583 {
07584 if (!invalidationReason().isEmpty()) {
07585 return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
07586 invalidationReason(),
07587 invalidationMessage()
07588 ));
07589 }
07590
07591 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07592 this->staticInterfaceName(), QLatin1String("AddContent"));
07593 callMessage << QVariant::fromValue(contentName) << QVariant::fromValue(contentType) << QVariant::fromValue(initialDirection);
07594 return this->connection().asyncCall(callMessage, timeout);
07595 }
07596
07597 Q_SIGNALS:
07609 void ContentAdded(const QDBusObjectPath& content);
07610
07626 void ContentRemoved(const QDBusObjectPath& content, const Tp::CallStateReason& reason);
07627
07655 void CallStateChanged(uint callState, uint callFlags, const Tp::CallStateReason& callStateReason, const QVariantMap& callStateDetails);
07656
07685 void CallMembersChanged(const Tp::CallMemberMap& flagsChanged, const Tp::HandleIdentifierMap& identifiers, const Tp::UIntList& removed, const Tp::CallStateReason& reason);
07686
07687 protected:
07688 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07689 };
07690
07698 class TP_QT_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
07699 {
07700 Q_OBJECT
07701
07702 public:
07709 static inline QLatin1String staticInterfaceName()
07710 {
07711 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
07712 }
07713
07721 ChannelTypeContactListInterface(
07722 const QString& busName,
07723 const QString& objectPath,
07724 QObject* parent = 0
07725 );
07726
07735 ChannelTypeContactListInterface(
07736 const QDBusConnection& connection,
07737 const QString& busName,
07738 const QString& objectPath,
07739 QObject* parent = 0
07740 );
07741
07748 ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
07749
07757 explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
07758
07766 ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07767
07774 Tp::PendingVariantMap *requestAllProperties() const
07775 {
07776 return internalRequestAllProperties();
07777 }
07778
07779 protected:
07780 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07781 };
07782
07790 class TP_QT_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
07791 {
07792 Q_OBJECT
07793
07794 public:
07801 static inline QLatin1String staticInterfaceName()
07802 {
07803 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
07804 }
07805
07813 ChannelTypeContactSearchInterface(
07814 const QString& busName,
07815 const QString& objectPath,
07816 QObject* parent = 0
07817 );
07818
07827 ChannelTypeContactSearchInterface(
07828 const QDBusConnection& connection,
07829 const QString& busName,
07830 const QString& objectPath,
07831 QObject* parent = 0
07832 );
07833
07840 ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
07841
07849 explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
07850
07858 ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07859
07870 inline Tp::PendingVariant *requestPropertySearchState() const
07871 {
07872 return internalRequestProperty(QLatin1String("SearchState"));
07873 }
07874
07900 inline Tp::PendingVariant *requestPropertyLimit() const
07901 {
07902 return internalRequestProperty(QLatin1String("Limit"));
07903 }
07904
07919 inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
07920 {
07921 return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
07922 }
07923
07944 inline Tp::PendingVariant *requestPropertyServer() const
07945 {
07946 return internalRequestProperty(QLatin1String("Server"));
07947 }
07948
07955 Tp::PendingVariantMap *requestAllProperties() const
07956 {
07957 return internalRequestAllProperties();
07958 }
07959
07960 public Q_SLOTS:
07978 inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
07979 {
07980 if (!invalidationReason().isEmpty()) {
07981 return QDBusPendingReply<>(QDBusMessage::createError(
07982 invalidationReason(),
07983 invalidationMessage()
07984 ));
07985 }
07986
07987 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07988 this->staticInterfaceName(), QLatin1String("Search"));
07989 callMessage << QVariant::fromValue(terms);
07990 return this->connection().asyncCall(callMessage, timeout);
07991 }
07992
08007 inline QDBusPendingReply<> More(int timeout = -1)
08008 {
08009 if (!invalidationReason().isEmpty()) {
08010 return QDBusPendingReply<>(QDBusMessage::createError(
08011 invalidationReason(),
08012 invalidationMessage()
08013 ));
08014 }
08015
08016 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08017 this->staticInterfaceName(), QLatin1String("More"));
08018 return this->connection().asyncCall(callMessage, timeout);
08019 }
08020
08053 inline QDBusPendingReply<> Stop(int timeout = -1)
08054 {
08055 if (!invalidationReason().isEmpty()) {
08056 return QDBusPendingReply<>(QDBusMessage::createError(
08057 invalidationReason(),
08058 invalidationMessage()
08059 ));
08060 }
08061
08062 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08063 this->staticInterfaceName(), QLatin1String("Stop"));
08064 return this->connection().asyncCall(callMessage, timeout);
08065 }
08066
08067 Q_SIGNALS:
08117 void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
08118
08131 void SearchResultReceived(const Tp::ContactSearchResultMap& result);
08132
08133 protected:
08134 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08135 };
08136
08144 class TP_QT_EXPORT ChannelTypeDBusTubeInterface : public Tp::AbstractInterface
08145 {
08146 Q_OBJECT
08147
08148 public:
08155 static inline QLatin1String staticInterfaceName()
08156 {
08157 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.DBusTube");
08158 }
08159
08167 ChannelTypeDBusTubeInterface(
08168 const QString& busName,
08169 const QString& objectPath,
08170 QObject* parent = 0
08171 );
08172
08181 ChannelTypeDBusTubeInterface(
08182 const QDBusConnection& connection,
08183 const QString& busName,
08184 const QString& objectPath,
08185 QObject* parent = 0
08186 );
08187
08194 ChannelTypeDBusTubeInterface(Tp::DBusProxy *proxy);
08195
08203 explicit ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
08204
08212 ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
08213
08232 inline Tp::PendingVariant *requestPropertyServiceName() const
08233 {
08234 return internalRequestProperty(QLatin1String("ServiceName"));
08235 }
08236
08249 inline Tp::PendingVariant *requestPropertyDBusNames() const
08250 {
08251 return internalRequestProperty(QLatin1String("DBusNames"));
08252 }
08253
08281 inline Tp::PendingVariant *requestPropertySupportedAccessControls() const
08282 {
08283 return internalRequestProperty(QLatin1String("SupportedAccessControls"));
08284 }
08285
08292 Tp::PendingVariantMap *requestAllProperties() const
08293 {
08294 return internalRequestAllProperties();
08295 }
08296
08297 public Q_SLOTS:
08322 inline QDBusPendingReply<QString> Offer(const QVariantMap& parameters, uint accesscontrol, int timeout = -1)
08323 {
08324 if (!invalidationReason().isEmpty()) {
08325 return QDBusPendingReply<QString>(QDBusMessage::createError(
08326 invalidationReason(),
08327 invalidationMessage()
08328 ));
08329 }
08330
08331 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08332 this->staticInterfaceName(), QLatin1String("Offer"));
08333 callMessage << QVariant::fromValue(parameters) << QVariant::fromValue(accesscontrol);
08334 return this->connection().asyncCall(callMessage, timeout);
08335 }
08336
08360 inline QDBusPendingReply<QString> Accept(uint accesscontrol, int timeout = -1)
08361 {
08362 if (!invalidationReason().isEmpty()) {
08363 return QDBusPendingReply<QString>(QDBusMessage::createError(
08364 invalidationReason(),
08365 invalidationMessage()
08366 ));
08367 }
08368
08369 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08370 this->staticInterfaceName(), QLatin1String("Accept"));
08371 callMessage << QVariant::fromValue(accesscontrol);
08372 return this->connection().asyncCall(callMessage, timeout);
08373 }
08374
08375 Q_SIGNALS:
08391 void DBusNamesChanged(const Tp::DBusTubeParticipants& added, const Tp::UIntList& removed);
08392
08393 protected:
08394 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08395 };
08396
08404 class TP_QT_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
08405 {
08406 Q_OBJECT
08407
08408 public:
08415 static inline QLatin1String staticInterfaceName()
08416 {
08417 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
08418 }
08419
08427 ChannelTypeFileTransferInterface(
08428 const QString& busName,
08429 const QString& objectPath,
08430 QObject* parent = 0
08431 );
08432
08441 ChannelTypeFileTransferInterface(
08442 const QDBusConnection& connection,
08443 const QString& busName,
08444 const QString& objectPath,
08445 QObject* parent = 0
08446 );
08447
08454 ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
08455
08463 explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
08464
08472 ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
08473
08486 inline Tp::PendingVariant *requestPropertyState() const
08487 {
08488 return internalRequestProperty(QLatin1String("State"));
08489 }
08490
08508 inline Tp::PendingVariant *requestPropertyContentType() const
08509 {
08510 return internalRequestProperty(QLatin1String("ContentType"));
08511 }
08512
08534 inline Tp::PendingVariant *requestPropertyFilename() const
08535 {
08536 return internalRequestProperty(QLatin1String("Filename"));
08537 }
08538
08562 inline Tp::PendingVariant *requestPropertySize() const
08563 {
08564 return internalRequestProperty(QLatin1String("Size"));
08565 }
08566
08593 inline Tp::PendingVariant *requestPropertyContentHashType() const
08594 {
08595 return internalRequestProperty(QLatin1String("ContentHashType"));
08596 }
08597
08618 inline Tp::PendingVariant *requestPropertyContentHash() const
08619 {
08620 return internalRequestProperty(QLatin1String("ContentHash"));
08621 }
08622
08640 inline Tp::PendingVariant *requestPropertyDescription() const
08641 {
08642 return internalRequestProperty(QLatin1String("Description"));
08643 }
08644
08661 inline Tp::PendingVariant *requestPropertyDate() const
08662 {
08663 return internalRequestProperty(QLatin1String("Date"));
08664 }
08665
08694 inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
08695 {
08696 return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
08697 }
08698
08712 inline Tp::PendingVariant *requestPropertyTransferredBytes() const
08713 {
08714 return internalRequestProperty(QLatin1String("TransferredBytes"));
08715 }
08716
08739 inline Tp::PendingVariant *requestPropertyInitialOffset() const
08740 {
08741 return internalRequestProperty(QLatin1String("InitialOffset"));
08742 }
08743
08779 inline Tp::PendingVariant *requestPropertyURI() const
08780 {
08781 return internalRequestProperty(QLatin1String("URI"));
08782 }
08783
08819 inline Tp::PendingOperation *setPropertyURI(QString newValue)
08820 {
08821 return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
08822 }
08823
08856 inline Tp::PendingVariant *requestPropertyFileCollection() const
08857 {
08858 return internalRequestProperty(QLatin1String("FileCollection"));
08859 }
08860
08867 Tp::PendingVariantMap *requestAllProperties() const
08868 {
08869 return internalRequestAllProperties();
08870 }
08871
08872 public Q_SLOTS:
08917 inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
08918 {
08919 if (!invalidationReason().isEmpty()) {
08920 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
08921 invalidationReason(),
08922 invalidationMessage()
08923 ));
08924 }
08925
08926 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08927 this->staticInterfaceName(), QLatin1String("AcceptFile"));
08928 callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
08929 return this->connection().asyncCall(callMessage, timeout);
08930 }
08931
08965 inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
08966 {
08967 if (!invalidationReason().isEmpty()) {
08968 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
08969 invalidationReason(),
08970 invalidationMessage()
08971 ));
08972 }
08973
08974 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08975 this->staticInterfaceName(), QLatin1String("ProvideFile"));
08976 callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
08977 return this->connection().asyncCall(callMessage, timeout);
08978 }
08979
08980 Q_SIGNALS:
08998 void FileTransferStateChanged(uint state, uint reason);
08999
09012 void TransferredBytesChanged(qulonglong count);
09013
09025 void InitialOffsetDefined(qulonglong initialOffset);
09026
09038 void URIDefined(const QString& URI);
09039
09040 protected:
09041 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09042 };
09043
09051 class TP_QT_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
09052 {
09053 Q_OBJECT
09054
09055 public:
09062 static inline QLatin1String staticInterfaceName()
09063 {
09064 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
09065 }
09066
09074 ChannelTypeRoomListInterface(
09075 const QString& busName,
09076 const QString& objectPath,
09077 QObject* parent = 0
09078 );
09079
09088 ChannelTypeRoomListInterface(
09089 const QDBusConnection& connection,
09090 const QString& busName,
09091 const QString& objectPath,
09092 QObject* parent = 0
09093 );
09094
09101 ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
09102
09110 explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
09111
09119 ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09120
09134 inline Tp::PendingVariant *requestPropertyServer() const
09135 {
09136 return internalRequestProperty(QLatin1String("Server"));
09137 }
09138
09145 Tp::PendingVariantMap *requestAllProperties() const
09146 {
09147 return internalRequestAllProperties();
09148 }
09149
09150 public Q_SLOTS:
09166 inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
09167 {
09168 if (!invalidationReason().isEmpty()) {
09169 return QDBusPendingReply<bool>(QDBusMessage::createError(
09170 invalidationReason(),
09171 invalidationMessage()
09172 ));
09173 }
09174
09175 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09176 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
09177 return this->connection().asyncCall(callMessage, timeout);
09178 }
09179
09193 inline QDBusPendingReply<> ListRooms(int timeout = -1)
09194 {
09195 if (!invalidationReason().isEmpty()) {
09196 return QDBusPendingReply<>(QDBusMessage::createError(
09197 invalidationReason(),
09198 invalidationMessage()
09199 ));
09200 }
09201
09202 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09203 this->staticInterfaceName(), QLatin1String("ListRooms"));
09204 return this->connection().asyncCall(callMessage, timeout);
09205 }
09206
09219 inline QDBusPendingReply<> StopListing(int timeout = -1)
09220 {
09221 if (!invalidationReason().isEmpty()) {
09222 return QDBusPendingReply<>(QDBusMessage::createError(
09223 invalidationReason(),
09224 invalidationMessage()
09225 ));
09226 }
09227
09228 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09229 this->staticInterfaceName(), QLatin1String("StopListing"));
09230 return this->connection().asyncCall(callMessage, timeout);
09231 }
09232
09233 Q_SIGNALS:
09292 void GotRooms(const Tp::RoomInfoList& rooms);
09293
09304 void ListingRooms(bool listing);
09305
09306 protected:
09307 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09308 };
09309
09317 class TP_QT_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
09318 {
09319 Q_OBJECT
09320
09321 public:
09328 static inline QLatin1String staticInterfaceName()
09329 {
09330 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
09331 }
09332
09340 ChannelTypeServerAuthenticationInterface(
09341 const QString& busName,
09342 const QString& objectPath,
09343 QObject* parent = 0
09344 );
09345
09354 ChannelTypeServerAuthenticationInterface(
09355 const QDBusConnection& connection,
09356 const QString& busName,
09357 const QString& objectPath,
09358 QObject* parent = 0
09359 );
09360
09367 ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
09368
09376 explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
09377
09385 ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09386
09403 inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
09404 {
09405 return internalRequestProperty(QLatin1String("AuthenticationMethod"));
09406 }
09407
09414 Tp::PendingVariantMap *requestAllProperties() const
09415 {
09416 return internalRequestAllProperties();
09417 }
09418
09419 protected:
09420 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09421 };
09422
09430 class TP_QT_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
09431 {
09432 Q_OBJECT
09433
09434 public:
09441 static inline QLatin1String staticInterfaceName()
09442 {
09443 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
09444 }
09445
09453 ChannelTypeServerTLSConnectionInterface(
09454 const QString& busName,
09455 const QString& objectPath,
09456 QObject* parent = 0
09457 );
09458
09467 ChannelTypeServerTLSConnectionInterface(
09468 const QDBusConnection& connection,
09469 const QString& busName,
09470 const QString& objectPath,
09471 QObject* parent = 0
09472 );
09473
09480 ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
09481
09489 explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
09490
09498 ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09499
09510 inline Tp::PendingVariant *requestPropertyServerCertificate() const
09511 {
09512 return internalRequestProperty(QLatin1String("ServerCertificate"));
09513 }
09514
09528 inline Tp::PendingVariant *requestPropertyHostname() const
09529 {
09530 return internalRequestProperty(QLatin1String("Hostname"));
09531 }
09532
09559 inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
09560 {
09561 return internalRequestProperty(QLatin1String("ReferenceIdentities"));
09562 }
09563
09570 Tp::PendingVariantMap *requestAllProperties() const
09571 {
09572 return internalRequestAllProperties();
09573 }
09574
09575 protected:
09576 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09577 };
09578
09586 class TP_QT_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
09587 {
09588 Q_OBJECT
09589
09590 public:
09597 static inline QLatin1String staticInterfaceName()
09598 {
09599 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
09600 }
09601
09609 ChannelTypeStreamTubeInterface(
09610 const QString& busName,
09611 const QString& objectPath,
09612 QObject* parent = 0
09613 );
09614
09623 ChannelTypeStreamTubeInterface(
09624 const QDBusConnection& connection,
09625 const QString& busName,
09626 const QString& objectPath,
09627 QObject* parent = 0
09628 );
09629
09636 ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
09637
09645 explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
09646
09654 ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
09655
09678 inline Tp::PendingVariant *requestPropertyService() const
09679 {
09680 return internalRequestProperty(QLatin1String("Service"));
09681 }
09682
09717 inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
09718 {
09719 return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
09720 }
09721
09728 Tp::PendingVariantMap *requestAllProperties() const
09729 {
09730 return internalRequestAllProperties();
09731 }
09732
09733 public Q_SLOTS:
09764 inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
09765 {
09766 if (!invalidationReason().isEmpty()) {
09767 return QDBusPendingReply<>(QDBusMessage::createError(
09768 invalidationReason(),
09769 invalidationMessage()
09770 ));
09771 }
09772
09773 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09774 this->staticInterfaceName(), QLatin1String("Offer"));
09775 callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
09776 return this->connection().asyncCall(callMessage, timeout);
09777 }
09778
09819 inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
09820 {
09821 if (!invalidationReason().isEmpty()) {
09822 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
09823 invalidationReason(),
09824 invalidationMessage()
09825 ));
09826 }
09827
09828 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
09829 this->staticInterfaceName(), QLatin1String("Accept"));
09830 callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
09831 return this->connection().asyncCall(callMessage, timeout);
09832 }
09833
09834 Q_SIGNALS:
09875 void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
09876
09892 void NewLocalConnection(uint connectionID);
09893
09925 void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
09926
09927 protected:
09928 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
09929 };
09930
09938 class TP_QT_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
09939 {
09940 Q_OBJECT
09941
09942 public:
09949 static inline QLatin1String staticInterfaceName()
09950 {
09951 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
09952 }
09953
09961 ChannelTypeStreamedMediaInterface(
09962 const QString& busName,
09963 const QString& objectPath,
09964 QObject* parent = 0
09965 );
09966
09975 ChannelTypeStreamedMediaInterface(
09976 const QDBusConnection& connection,
09977 const QString& busName,
09978 const QString& objectPath,
09979 QObject* parent = 0
09980 );
09981
09988 ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
09989
09997 explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
09998
10006 ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
10007
10096 inline Tp::PendingVariant *requestPropertyInitialAudio() const
10097 {
10098 return internalRequestProperty(QLatin1String("InitialAudio"));
10099 }
10100
10121 inline Tp::PendingVariant *requestPropertyInitialVideo() const
10122 {
10123 return internalRequestProperty(QLatin1String("InitialVideo"));
10124 }
10125
10168 inline Tp::PendingVariant *requestPropertyImmutableStreams() const
10169 {
10170 return internalRequestProperty(QLatin1String("ImmutableStreams"));
10171 }
10172
10179 Tp::PendingVariantMap *requestAllProperties() const
10180 {
10181 return internalRequestAllProperties();
10182 }
10183
10184 public Q_SLOTS:
10212 inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
10213 {
10214 if (!invalidationReason().isEmpty()) {
10215 return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
10216 invalidationReason(),
10217 invalidationMessage()
10218 ));
10219 }
10220
10221 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10222 this->staticInterfaceName(), QLatin1String("ListStreams"));
10223 return this->connection().asyncCall(callMessage, timeout);
10224 }
10225
10252 inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
10253 {
10254 if (!invalidationReason().isEmpty()) {
10255 return QDBusPendingReply<>(QDBusMessage::createError(
10256 invalidationReason(),
10257 invalidationMessage()
10258 ));
10259 }
10260
10261 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10262 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
10263 callMessage << QVariant::fromValue(streams);
10264 return this->connection().asyncCall(callMessage, timeout);
10265 }
10266
10303 inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
10304 {
10305 if (!invalidationReason().isEmpty()) {
10306 return QDBusPendingReply<>(QDBusMessage::createError(
10307 invalidationReason(),
10308 invalidationMessage()
10309 ));
10310 }
10311
10312 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10313 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
10314 callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
10315 return this->connection().asyncCall(callMessage, timeout);
10316 }
10317
10370 inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
10371 {
10372 if (!invalidationReason().isEmpty()) {
10373 return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
10374 invalidationReason(),
10375 invalidationMessage()
10376 ));
10377 }
10378
10379 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10380 this->staticInterfaceName(), QLatin1String("RequestStreams"));
10381 callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
10382 return this->connection().asyncCall(callMessage, timeout);
10383 }
10384
10385 Q_SIGNALS:
10452 void StreamAdded(uint streamID, uint contactHandle, uint streamType);
10453
10485 void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
10486
10504 void StreamError(uint streamID, uint errorCode, const QString& message);
10505
10515 void StreamRemoved(uint streamID);
10516
10530 void StreamStateChanged(uint streamID, uint streamState);
10531
10532 protected:
10533 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
10534 };
10535
10543 class TP_QT_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
10544 {
10545 Q_OBJECT
10546
10547 public:
10554 static inline QLatin1String staticInterfaceName()
10555 {
10556 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
10557 }
10558
10566 ChannelTypeTextInterface(
10567 const QString& busName,
10568 const QString& objectPath,
10569 QObject* parent = 0
10570 );
10571
10580 ChannelTypeTextInterface(
10581 const QDBusConnection& connection,
10582 const QString& busName,
10583 const QString& objectPath,
10584 QObject* parent = 0
10585 );
10586
10593 ChannelTypeTextInterface(Tp::DBusProxy *proxy);
10594
10602 explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
10603
10611 ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
10612
10619 Tp::PendingVariantMap *requestAllProperties() const
10620 {
10621 return internalRequestAllProperties();
10622 }
10623
10624 public Q_SLOTS:
10640 inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
10641 {
10642 if (!invalidationReason().isEmpty()) {
10643 return QDBusPendingReply<>(QDBusMessage::createError(
10644 invalidationReason(),
10645 invalidationMessage()
10646 ));
10647 }
10648
10649 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10650 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
10651 callMessage << QVariant::fromValue(IDs);
10652 return this->connection().asyncCall(callMessage, timeout);
10653 }
10654
10670 inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
10671 {
10672 if (!invalidationReason().isEmpty()) {
10673 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
10674 invalidationReason(),
10675 invalidationMessage()
10676 ));
10677 }
10678
10679 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10680 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
10681 return this->connection().asyncCall(callMessage, timeout);
10682 }
10683
10714 inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
10715 {
10716 if (!invalidationReason().isEmpty()) {
10717 return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
10718 invalidationReason(),
10719 invalidationMessage()
10720 ));
10721 }
10722
10723 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10724 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
10725 callMessage << QVariant::fromValue(clear);
10726 return this->connection().asyncCall(callMessage, timeout);
10727 }
10728
10761 inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
10762 {
10763 if (!invalidationReason().isEmpty()) {
10764 return QDBusPendingReply<>(QDBusMessage::createError(
10765 invalidationReason(),
10766 invalidationMessage()
10767 ));
10768 }
10769
10770 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
10771 this->staticInterfaceName(), QLatin1String("Send"));
10772 callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
10773 return this->connection().asyncCall(callMessage, timeout);
10774 }
10775
10776 Q_SIGNALS:
10784 void LostMessage();
10785
10819 void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
10820
10849 void SendError(uint error, uint timestamp, uint type, const QString& text);
10850
10874 void Sent(uint timestamp, uint type, const QString& text);
10875
10876 protected:
10877 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
10878 };
10879
10887 class TP_QT_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
10888 {
10889 Q_OBJECT
10890
10891 public:
10898 static inline QLatin1String staticInterfaceName()
10899 {
10900 return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
10901 }
10902
10910 ChannelTypeTubesInterface(
10911 const QString& busName,
10912 const QString& objectPath,
10913 QObject* parent = 0
10914 );
10915
10924 ChannelTypeTubesInterface(
10925 const QDBusConnection& connection,
10926 const QString& busName,
10927 const QString& objectPath,
10928 QObject* parent = 0
10929 );
10930
10937 ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
10938
10946 explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
10947
10955 ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
10956
10963 Tp::PendingVariantMap *requestAllProperties() const
10964 {
10965 return internalRequestAllProperties();
10966 }
10967
10968 public Q_SLOTS:
11005 inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
11006 {
11007 if (!invalidationReason().isEmpty()) {
11008 return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
11009 invalidationReason(),
11010 invalidationMessage()
11011 ));
11012 }
11013
11014 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11015 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
11016 return this->connection().asyncCall(callMessage, timeout);
11017 }
11018
11032 inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
11033 {
11034 if (!invalidationReason().isEmpty()) {
11035 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
11036 invalidationReason(),
11037 invalidationMessage()
11038 ));
11039 }
11040
11041 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11042 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
11043 return this->connection().asyncCall(callMessage, timeout);
11044 }
11045
11061 inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
11062 {
11063 if (!invalidationReason().isEmpty()) {
11064 return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
11065 invalidationReason(),
11066 invalidationMessage()
11067 ));
11068 }
11069
11070 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11071 this->staticInterfaceName(), QLatin1String("ListTubes"));
11072 return this->connection().asyncCall(callMessage, timeout);
11073 }
11074
11102 inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
11103 {
11104 if (!invalidationReason().isEmpty()) {
11105 return QDBusPendingReply<uint>(QDBusMessage::createError(
11106 invalidationReason(),
11107 invalidationMessage()
11108 ));
11109 }
11110
11111 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11112 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
11113 callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
11114 return this->connection().asyncCall(callMessage, timeout);
11115 }
11116
11176 inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
11177 {
11178 if (!invalidationReason().isEmpty()) {
11179 return QDBusPendingReply<uint>(QDBusMessage::createError(
11180 invalidationReason(),
11181 invalidationMessage()
11182 ));
11183 }
11184
11185 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11186 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
11187 callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
11188 return this->connection().asyncCall(callMessage, timeout);
11189 }
11190
11213 inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
11214 {
11215 if (!invalidationReason().isEmpty()) {
11216 return QDBusPendingReply<QString>(QDBusMessage::createError(
11217 invalidationReason(),
11218 invalidationMessage()
11219 ));
11220 }
11221
11222 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11223 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
11224 callMessage << QVariant::fromValue(ID);
11225 return this->connection().asyncCall(callMessage, timeout);
11226 }
11227
11265 inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
11266 {
11267 if (!invalidationReason().isEmpty()) {
11268 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
11269 invalidationReason(),
11270 invalidationMessage()
11271 ));
11272 }
11273
11274 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11275 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
11276 callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
11277 return this->connection().asyncCall(callMessage, timeout);
11278 }
11279
11294 inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
11295 {
11296 if (!invalidationReason().isEmpty()) {
11297 return QDBusPendingReply<>(QDBusMessage::createError(
11298 invalidationReason(),
11299 invalidationMessage()
11300 ));
11301 }
11302
11303 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11304 this->staticInterfaceName(), QLatin1String("CloseTube"));
11305 callMessage << QVariant::fromValue(ID);
11306 return this->connection().asyncCall(callMessage, timeout);
11307 }
11308
11328 inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
11329 {
11330 if (!invalidationReason().isEmpty()) {
11331 return QDBusPendingReply<QString>(QDBusMessage::createError(
11332 invalidationReason(),
11333 invalidationMessage()
11334 ));
11335 }
11336
11337 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11338 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
11339 callMessage << QVariant::fromValue(ID);
11340 return this->connection().asyncCall(callMessage, timeout);
11341 }
11342
11363 inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
11364 {
11365 if (!invalidationReason().isEmpty()) {
11366 return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
11367 invalidationReason(),
11368 invalidationMessage()
11369 ));
11370 }
11371
11372 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11373 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
11374 callMessage << QVariant::fromValue(ID);
11375 return this->connection().asyncCall(callMessage, timeout);
11376 }
11377
11403 inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
11404 {
11405 if (!invalidationReason().isEmpty()) {
11406 return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
11407 invalidationReason(),
11408 invalidationMessage()
11409 ));
11410 }
11411
11412 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
11413 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
11414 callMessage << QVariant::fromValue(ID);
11415 return this->connection().asyncCall(callMessage, timeout);
11416 }
11417
11418 Q_SIGNALS:
11448 void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
11449
11463 void TubeStateChanged(uint ID, uint state);
11464
11475 void TubeClosed(uint ID);
11476
11495 void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
11496
11511 void StreamTubeNewConnection(uint ID, uint handle);
11512
11513 protected:
11514 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
11515 };
11516 }
11517 }
11518 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
11519 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
11520 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
11521 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface*)
11522 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
11523 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
11524 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
11525 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDestroyableInterface*)
11526 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceFileTransferMetadataInterface*)
11527 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
11528 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
11529 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
11530 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
11531 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
11532 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceRoomConfigInterface*)
11533 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceRoomInterface*)
11534 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
11535 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSMSInterface*)
11536 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
11537 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
11538 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSubjectInterface*)
11539 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
11540 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeCallInterface*)
11541 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
11542 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
11543 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeDBusTubeInterface*)
11544 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
11545 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
11546 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
11547 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
11548 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
11549 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
11550 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
11551 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)