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 ConnectionInterface : public Tp::AbstractInterface
00045 {
00046 Q_OBJECT
00047
00048 public:
00055 static inline QLatin1String staticInterfaceName()
00056 {
00057 return QLatin1String("org.freedesktop.Telepathy.Connection");
00058 }
00059
00067 ConnectionInterface(
00068 const QString& busName,
00069 const QString& objectPath,
00070 QObject* parent = 0
00071 );
00072
00081 ConnectionInterface(
00082 const QDBusConnection& connection,
00083 const QString& busName,
00084 const QString& objectPath,
00085 QObject* parent = 0
00086 );
00087
00094 ConnectionInterface(Tp::DBusProxy *proxy);
00095
00127 inline Tp::PendingVariant *requestPropertyInterfaces() const
00128 {
00129 return internalRequestProperty(QLatin1String("Interfaces"));
00130 }
00131
00145 inline Tp::PendingVariant *requestPropertySelfHandle() const
00146 {
00147 return internalRequestProperty(QLatin1String("SelfHandle"));
00148 }
00149
00163 inline Tp::PendingVariant *requestPropertySelfID() const
00164 {
00165 return internalRequestProperty(QLatin1String("SelfID"));
00166 }
00167
00186 inline Tp::PendingVariant *requestPropertyStatus() const
00187 {
00188 return internalRequestProperty(QLatin1String("Status"));
00189 }
00190
00205 inline Tp::PendingVariant *requestPropertyHasImmortalHandles() const
00206 {
00207 return internalRequestProperty(QLatin1String("HasImmortalHandles"));
00208 }
00209
00216 Tp::PendingVariantMap *requestAllProperties() const
00217 {
00218 return internalRequestAllProperties();
00219 }
00220
00221 public Q_SLOTS:
00239 inline QDBusPendingReply<> Connect(int timeout = -1)
00240 {
00241 if (!invalidationReason().isEmpty()) {
00242 return QDBusPendingReply<>(QDBusMessage::createError(
00243 invalidationReason(),
00244 invalidationMessage()
00245 ));
00246 }
00247
00248 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00249 this->staticInterfaceName(), QLatin1String("Connect"));
00250 return this->connection().asyncCall(callMessage, timeout);
00251 }
00252
00265 inline QDBusPendingReply<> Disconnect(int timeout = -1)
00266 {
00267 if (!invalidationReason().isEmpty()) {
00268 return QDBusPendingReply<>(QDBusMessage::createError(
00269 invalidationReason(),
00270 invalidationMessage()
00271 ));
00272 }
00273
00274 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00275 this->staticInterfaceName(), QLatin1String("Disconnect"));
00276 return this->connection().asyncCall(callMessage, timeout);
00277 }
00278
00297 inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00298 {
00299 if (!invalidationReason().isEmpty()) {
00300 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00301 invalidationReason(),
00302 invalidationMessage()
00303 ));
00304 }
00305
00306 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00307 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00308 return this->connection().asyncCall(callMessage, timeout);
00309 }
00310
00325 inline QDBusPendingReply<QString> GetProtocol(int timeout = -1)
00326 {
00327 if (!invalidationReason().isEmpty()) {
00328 return QDBusPendingReply<QString>(QDBusMessage::createError(
00329 invalidationReason(),
00330 invalidationMessage()
00331 ));
00332 }
00333
00334 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00335 this->staticInterfaceName(), QLatin1String("GetProtocol"));
00336 return this->connection().asyncCall(callMessage, timeout);
00337 }
00338
00354 inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
00355 {
00356 if (!invalidationReason().isEmpty()) {
00357 return QDBusPendingReply<uint>(QDBusMessage::createError(
00358 invalidationReason(),
00359 invalidationMessage()
00360 ));
00361 }
00362
00363 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00364 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
00365 return this->connection().asyncCall(callMessage, timeout);
00366 }
00367
00382 inline QDBusPendingReply<uint> GetStatus(int timeout = -1)
00383 {
00384 if (!invalidationReason().isEmpty()) {
00385 return QDBusPendingReply<uint>(QDBusMessage::createError(
00386 invalidationReason(),
00387 invalidationMessage()
00388 ));
00389 }
00390
00391 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00392 this->staticInterfaceName(), QLatin1String("GetStatus"));
00393 return this->connection().asyncCall(callMessage, timeout);
00394 }
00395
00438 inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00439 {
00440 if (!invalidationReason().isEmpty()) {
00441 return QDBusPendingReply<>(QDBusMessage::createError(
00442 invalidationReason(),
00443 invalidationMessage()
00444 ));
00445 }
00446
00447 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00448 this->staticInterfaceName(), QLatin1String("HoldHandles"));
00449 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00450 return this->connection().asyncCall(callMessage, timeout);
00451 }
00452
00476 inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00477 {
00478 if (!invalidationReason().isEmpty()) {
00479 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00480 invalidationReason(),
00481 invalidationMessage()
00482 ));
00483 }
00484
00485 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00486 this->staticInterfaceName(), QLatin1String("InspectHandles"));
00487 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00488 return this->connection().asyncCall(callMessage, timeout);
00489 }
00490
00505 inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels(int timeout = -1)
00506 {
00507 if (!invalidationReason().isEmpty()) {
00508 return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00509 invalidationReason(),
00510 invalidationMessage()
00511 ));
00512 }
00513
00514 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00515 this->staticInterfaceName(), QLatin1String("ListChannels"));
00516 return this->connection().asyncCall(callMessage, timeout);
00517 }
00518
00544 inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00545 {
00546 if (!invalidationReason().isEmpty()) {
00547 return QDBusPendingReply<>(QDBusMessage::createError(
00548 invalidationReason(),
00549 invalidationMessage()
00550 ));
00551 }
00552
00553 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00554 this->staticInterfaceName(), QLatin1String("ReleaseHandles"));
00555 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00556 return this->connection().asyncCall(callMessage, timeout);
00557 }
00558
00638 inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler, int timeout = -1)
00639 {
00640 if (!invalidationReason().isEmpty()) {
00641 return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00642 invalidationReason(),
00643 invalidationMessage()
00644 ));
00645 }
00646
00647 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00648 this->staticInterfaceName(), QLatin1String("RequestChannel"));
00649 callMessage << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00650 return this->connection().asyncCall(callMessage, timeout);
00651 }
00652
00693 inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers, int timeout = -1)
00694 {
00695 if (!invalidationReason().isEmpty()) {
00696 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00697 invalidationReason(),
00698 invalidationMessage()
00699 ));
00700 }
00701
00702 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00703 this->staticInterfaceName(), QLatin1String("RequestHandles"));
00704 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
00705 return this->connection().asyncCall(callMessage, timeout);
00706 }
00707
00801 inline QDBusPendingReply<> AddClientInterest(const QStringList& tokens, int timeout = -1)
00802 {
00803 if (!invalidationReason().isEmpty()) {
00804 return QDBusPendingReply<>(QDBusMessage::createError(
00805 invalidationReason(),
00806 invalidationMessage()
00807 ));
00808 }
00809
00810 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00811 this->staticInterfaceName(), QLatin1String("AddClientInterest"));
00812 callMessage << QVariant::fromValue(tokens);
00813 return this->connection().asyncCall(callMessage, timeout);
00814 }
00815
00847 inline QDBusPendingReply<> RemoveClientInterest(const QStringList& tokens, int timeout = -1)
00848 {
00849 if (!invalidationReason().isEmpty()) {
00850 return QDBusPendingReply<>(QDBusMessage::createError(
00851 invalidationReason(),
00852 invalidationMessage()
00853 ));
00854 }
00855
00856 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00857 this->staticInterfaceName(), QLatin1String("RemoveClientInterest"));
00858 callMessage << QVariant::fromValue(tokens);
00859 return this->connection().asyncCall(callMessage, timeout);
00860 }
00861
00862 Q_SIGNALS:
00874 void SelfHandleChanged(uint selfHandle);
00875
00891 void SelfContactChanged(uint selfHandle, const QString& selfID);
00892
00936 void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00937
01007 void ConnectionError(const QString& error, const QVariantMap& details);
01008
01025 void StatusChanged(uint status, uint reason);
01026
01027 protected:
01028 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01029 };
01030
01038 class TP_QT_EXPORT ConnectionInterfaceAddressingInterface : public Tp::AbstractInterface
01039 {
01040 Q_OBJECT
01041
01042 public:
01049 static inline QLatin1String staticInterfaceName()
01050 {
01051 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Addressing1");
01052 }
01053
01061 ConnectionInterfaceAddressingInterface(
01062 const QString& busName,
01063 const QString& objectPath,
01064 QObject* parent = 0
01065 );
01066
01075 ConnectionInterfaceAddressingInterface(
01076 const QDBusConnection& connection,
01077 const QString& busName,
01078 const QString& objectPath,
01079 QObject* parent = 0
01080 );
01081
01088 ConnectionInterfaceAddressingInterface(Tp::DBusProxy *proxy);
01089
01097 explicit ConnectionInterfaceAddressingInterface(const Tp::Client::ConnectionInterface& mainInterface);
01098
01106 ConnectionInterfaceAddressingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01107
01114 Tp::PendingVariantMap *requestAllProperties() const
01115 {
01116 return internalRequestAllProperties();
01117 }
01118
01119 public Q_SLOTS:
01209 inline QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap> GetContactsByVCardField(const QString& field, const QStringList& addresses, const QStringList& interfaces, int timeout = -1)
01210 {
01211 if (!invalidationReason().isEmpty()) {
01212 return QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap>(QDBusMessage::createError(
01213 invalidationReason(),
01214 invalidationMessage()
01215 ));
01216 }
01217
01218 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01219 this->staticInterfaceName(), QLatin1String("GetContactsByVCardField"));
01220 callMessage << QVariant::fromValue(field) << QVariant::fromValue(addresses) << QVariant::fromValue(interfaces);
01221 return this->connection().asyncCall(callMessage, timeout);
01222 }
01223
01294 inline QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap> GetContactsByURI(const QStringList& URIs, const QStringList& interfaces, int timeout = -1)
01295 {
01296 if (!invalidationReason().isEmpty()) {
01297 return QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap>(QDBusMessage::createError(
01298 invalidationReason(),
01299 invalidationMessage()
01300 ));
01301 }
01302
01303 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01304 this->staticInterfaceName(), QLatin1String("GetContactsByURI"));
01305 callMessage << QVariant::fromValue(URIs) << QVariant::fromValue(interfaces);
01306 return this->connection().asyncCall(callMessage, timeout);
01307 }
01308
01309 protected:
01310 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01311 };
01312
01320 class TP_QT_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
01321 {
01322 Q_OBJECT
01323
01324 public:
01331 static inline QLatin1String staticInterfaceName()
01332 {
01333 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
01334 }
01335
01343 ConnectionInterfaceAliasingInterface(
01344 const QString& busName,
01345 const QString& objectPath,
01346 QObject* parent = 0
01347 );
01348
01357 ConnectionInterfaceAliasingInterface(
01358 const QDBusConnection& connection,
01359 const QString& busName,
01360 const QString& objectPath,
01361 QObject* parent = 0
01362 );
01363
01370 ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
01371
01379 explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
01380
01388 ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01389
01396 Tp::PendingVariantMap *requestAllProperties() const
01397 {
01398 return internalRequestAllProperties();
01399 }
01400
01401 public Q_SLOTS:
01417 inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
01418 {
01419 if (!invalidationReason().isEmpty()) {
01420 return QDBusPendingReply<uint>(QDBusMessage::createError(
01421 invalidationReason(),
01422 invalidationMessage()
01423 ));
01424 }
01425
01426 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01427 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
01428 return this->connection().asyncCall(callMessage, timeout);
01429 }
01430
01449 inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
01450 {
01451 if (!invalidationReason().isEmpty()) {
01452 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01453 invalidationReason(),
01454 invalidationMessage()
01455 ));
01456 }
01457
01458 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01459 this->staticInterfaceName(), QLatin1String("RequestAliases"));
01460 callMessage << QVariant::fromValue(contacts);
01461 return this->connection().asyncCall(callMessage, timeout);
01462 }
01463
01486 inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
01487 {
01488 if (!invalidationReason().isEmpty()) {
01489 return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
01490 invalidationReason(),
01491 invalidationMessage()
01492 ));
01493 }
01494
01495 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01496 this->staticInterfaceName(), QLatin1String("GetAliases"));
01497 callMessage << QVariant::fromValue(contacts);
01498 return this->connection().asyncCall(callMessage, timeout);
01499 }
01500
01520 inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
01521 {
01522 if (!invalidationReason().isEmpty()) {
01523 return QDBusPendingReply<>(QDBusMessage::createError(
01524 invalidationReason(),
01525 invalidationMessage()
01526 ));
01527 }
01528
01529 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01530 this->staticInterfaceName(), QLatin1String("SetAliases"));
01531 callMessage << QVariant::fromValue(aliases);
01532 return this->connection().asyncCall(callMessage, timeout);
01533 }
01534
01535 Q_SIGNALS:
01552 void AliasesChanged(const Tp::AliasPairList& aliases);
01553
01554 protected:
01555 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01556 };
01557
01565 class TP_QT_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
01566 {
01567 Q_OBJECT
01568
01569 public:
01576 static inline QLatin1String staticInterfaceName()
01577 {
01578 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
01579 }
01580
01588 ConnectionInterfaceAnonymityInterface(
01589 const QString& busName,
01590 const QString& objectPath,
01591 QObject* parent = 0
01592 );
01593
01602 ConnectionInterfaceAnonymityInterface(
01603 const QDBusConnection& connection,
01604 const QString& busName,
01605 const QString& objectPath,
01606 QObject* parent = 0
01607 );
01608
01615 ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
01616
01624 explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01625
01633 ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01634
01645 inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
01646 {
01647 return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
01648 }
01649
01665 inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
01666 {
01667 return internalRequestProperty(QLatin1String("AnonymityMandatory"));
01668 }
01669
01685 inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
01686 {
01687 return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
01688 }
01689
01702 inline Tp::PendingVariant *requestPropertyAnonymityModes() const
01703 {
01704 return internalRequestProperty(QLatin1String("AnonymityModes"));
01705 }
01706
01719 inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
01720 {
01721 return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
01722 }
01723
01730 Tp::PendingVariantMap *requestAllProperties() const
01731 {
01732 return internalRequestAllProperties();
01733 }
01734
01735 Q_SIGNALS:
01745 void AnonymityModesChanged(uint modes);
01746
01747 protected:
01748 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01749 };
01750
01758 class TP_QT_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01759 {
01760 Q_OBJECT
01761
01762 public:
01769 static inline QLatin1String staticInterfaceName()
01770 {
01771 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
01772 }
01773
01781 ConnectionInterfaceAvatarsInterface(
01782 const QString& busName,
01783 const QString& objectPath,
01784 QObject* parent = 0
01785 );
01786
01795 ConnectionInterfaceAvatarsInterface(
01796 const QDBusConnection& connection,
01797 const QString& busName,
01798 const QString& objectPath,
01799 QObject* parent = 0
01800 );
01801
01808 ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01809
01817 explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01818
01826 ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01827
01839 inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
01840 {
01841 return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
01842 }
01843
01855 inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
01856 {
01857 return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
01858 }
01859
01871 inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
01872 {
01873 return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
01874 }
01875
01890 inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
01891 {
01892 return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
01893 }
01894
01907 inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
01908 {
01909 return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
01910 }
01911
01923 inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
01924 {
01925 return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
01926 }
01927
01939 inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
01940 {
01941 return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
01942 }
01943
01955 inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
01956 {
01957 return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
01958 }
01959
01966 Tp::PendingVariantMap *requestAllProperties() const
01967 {
01968 return internalRequestAllProperties();
01969 }
01970
01971 public Q_SLOTS:
02006 inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
02007 {
02008 if (!invalidationReason().isEmpty()) {
02009 return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
02010 invalidationReason(),
02011 invalidationMessage()
02012 ));
02013 }
02014
02015 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02016 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
02017 return this->connection().asyncCall(callMessage, timeout);
02018 }
02019
02041 inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
02042 {
02043 if (!invalidationReason().isEmpty()) {
02044 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02045 invalidationReason(),
02046 invalidationMessage()
02047 ));
02048 }
02049
02050 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02051 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
02052 callMessage << QVariant::fromValue(contacts);
02053 return this->connection().asyncCall(callMessage, timeout);
02054 }
02055
02083 inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
02084 {
02085 if (!invalidationReason().isEmpty()) {
02086 return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
02087 invalidationReason(),
02088 invalidationMessage()
02089 ));
02090 }
02091
02092 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02093 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
02094 callMessage << QVariant::fromValue(contacts);
02095 return this->connection().asyncCall(callMessage, timeout);
02096 }
02097
02122 inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
02123 {
02124 if (!invalidationReason().isEmpty()) {
02125 return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
02126 invalidationReason(),
02127 invalidationMessage()
02128 ));
02129 }
02130
02131 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02132 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
02133 callMessage << QVariant::fromValue(contact);
02134 return this->connection().asyncCall(callMessage, timeout);
02135 }
02136
02155 inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
02156 {
02157 if (!invalidationReason().isEmpty()) {
02158 return QDBusPendingReply<>(QDBusMessage::createError(
02159 invalidationReason(),
02160 invalidationMessage()
02161 ));
02162 }
02163
02164 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02165 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
02166 callMessage << QVariant::fromValue(contacts);
02167 return this->connection().asyncCall(callMessage, timeout);
02168 }
02169
02193 inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
02194 {
02195 if (!invalidationReason().isEmpty()) {
02196 return QDBusPendingReply<QString>(QDBusMessage::createError(
02197 invalidationReason(),
02198 invalidationMessage()
02199 ));
02200 }
02201
02202 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02203 this->staticInterfaceName(), QLatin1String("SetAvatar"));
02204 callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
02205 return this->connection().asyncCall(callMessage, timeout);
02206 }
02207
02218 inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
02219 {
02220 if (!invalidationReason().isEmpty()) {
02221 return QDBusPendingReply<>(QDBusMessage::createError(
02222 invalidationReason(),
02223 invalidationMessage()
02224 ));
02225 }
02226
02227 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02228 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
02229 return this->connection().asyncCall(callMessage, timeout);
02230 }
02231
02232 Q_SIGNALS:
02249 void AvatarUpdated(uint contact, const QString& newAvatarToken);
02250
02273 void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
02274
02275 protected:
02276 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02277 };
02278
02286 class TP_QT_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
02287 {
02288 Q_OBJECT
02289
02290 public:
02297 static inline QLatin1String staticInterfaceName()
02298 {
02299 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
02300 }
02301
02309 ConnectionInterfaceBalanceInterface(
02310 const QString& busName,
02311 const QString& objectPath,
02312 QObject* parent = 0
02313 );
02314
02323 ConnectionInterfaceBalanceInterface(
02324 const QDBusConnection& connection,
02325 const QString& busName,
02326 const QString& objectPath,
02327 QObject* parent = 0
02328 );
02329
02336 ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
02337
02345 explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
02346
02354 ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02355
02374 inline Tp::PendingVariant *requestPropertyAccountBalance() const
02375 {
02376 return internalRequestProperty(QLatin1String("AccountBalance"));
02377 }
02378
02396 inline Tp::PendingVariant *requestPropertyManageCreditURI() const
02397 {
02398 return internalRequestProperty(QLatin1String("ManageCreditURI"));
02399 }
02400
02407 Tp::PendingVariantMap *requestAllProperties() const
02408 {
02409 return internalRequestAllProperties();
02410 }
02411
02412 Q_SIGNALS:
02427 void BalanceChanged(const Tp::CurrencyAmount& balance);
02428
02429 protected:
02430 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02431 };
02432
02440 class TP_QT_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
02441 {
02442 Q_OBJECT
02443
02444 public:
02451 static inline QLatin1String staticInterfaceName()
02452 {
02453 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
02454 }
02455
02463 ConnectionInterfaceCapabilitiesInterface(
02464 const QString& busName,
02465 const QString& objectPath,
02466 QObject* parent = 0
02467 );
02468
02477 ConnectionInterfaceCapabilitiesInterface(
02478 const QDBusConnection& connection,
02479 const QString& busName,
02480 const QString& objectPath,
02481 QObject* parent = 0
02482 );
02483
02490 ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
02491
02499 explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02500
02508 ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02509
02516 Tp::PendingVariantMap *requestAllProperties() const
02517 {
02518 return internalRequestAllProperties();
02519 }
02520
02521 public Q_SLOTS:
02575 inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
02576 {
02577 if (!invalidationReason().isEmpty()) {
02578 return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
02579 invalidationReason(),
02580 invalidationMessage()
02581 ));
02582 }
02583
02584 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02585 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
02586 callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
02587 return this->connection().asyncCall(callMessage, timeout);
02588 }
02589
02624 inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
02625 {
02626 if (!invalidationReason().isEmpty()) {
02627 return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
02628 invalidationReason(),
02629 invalidationMessage()
02630 ));
02631 }
02632
02633 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02634 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
02635 callMessage << QVariant::fromValue(handles);
02636 return this->connection().asyncCall(callMessage, timeout);
02637 }
02638
02639 Q_SIGNALS:
02666 void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
02667
02668 protected:
02669 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02670 };
02671
02679 class TP_QT_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
02680 {
02681 Q_OBJECT
02682
02683 public:
02690 static inline QLatin1String staticInterfaceName()
02691 {
02692 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
02693 }
02694
02702 ConnectionInterfaceCellularInterface(
02703 const QString& busName,
02704 const QString& objectPath,
02705 QObject* parent = 0
02706 );
02707
02716 ConnectionInterfaceCellularInterface(
02717 const QDBusConnection& connection,
02718 const QString& busName,
02719 const QString& objectPath,
02720 QObject* parent = 0
02721 );
02722
02729 ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02730
02738 explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02739
02747 ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02748
02767 inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
02768 {
02769 return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
02770 }
02771
02790 inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
02791 {
02792 return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
02793 }
02794
02817 inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
02818 {
02819 return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
02820 }
02821
02844 inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
02845 {
02846 return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
02847 }
02848
02865 inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
02866 {
02867 return internalRequestProperty(QLatin1String("MessageServiceCentre"));
02868 }
02869
02886 inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
02887 {
02888 return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
02889 }
02890
02904 inline Tp::PendingVariant *requestPropertyIMSI() const
02905 {
02906 return internalRequestProperty(QLatin1String("IMSI"));
02907 }
02908
02927 inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
02928 {
02929 return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
02930 }
02931
02950 inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
02951 {
02952 return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
02953 }
02954
02980 inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
02981 {
02982 return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
02983 }
02984
03010 inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
03011 {
03012 return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
03013 }
03014
03021 Tp::PendingVariantMap *requestAllProperties() const
03022 {
03023 return internalRequestAllProperties();
03024 }
03025
03026 Q_SIGNALS:
03042 void IMSIChanged(const QString& IMSI);
03043
03044 protected:
03045 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03046 };
03047
03055 class TP_QT_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
03056 {
03057 Q_OBJECT
03058
03059 public:
03066 static inline QLatin1String staticInterfaceName()
03067 {
03068 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
03069 }
03070
03078 ConnectionInterfaceClientTypesInterface(
03079 const QString& busName,
03080 const QString& objectPath,
03081 QObject* parent = 0
03082 );
03083
03092 ConnectionInterfaceClientTypesInterface(
03093 const QDBusConnection& connection,
03094 const QString& busName,
03095 const QString& objectPath,
03096 QObject* parent = 0
03097 );
03098
03105 ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
03106
03114 explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
03115
03123 ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03124
03131 Tp::PendingVariantMap *requestAllProperties() const
03132 {
03133 return internalRequestAllProperties();
03134 }
03135
03136 public Q_SLOTS:
03165 inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
03166 {
03167 if (!invalidationReason().isEmpty()) {
03168 return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
03169 invalidationReason(),
03170 invalidationMessage()
03171 ));
03172 }
03173
03174 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03175 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
03176 callMessage << QVariant::fromValue(contacts);
03177 return this->connection().asyncCall(callMessage, timeout);
03178 }
03179
03204 inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
03205 {
03206 if (!invalidationReason().isEmpty()) {
03207 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
03208 invalidationReason(),
03209 invalidationMessage()
03210 ));
03211 }
03212
03213 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03214 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
03215 callMessage << QVariant::fromValue(contact);
03216 return this->connection().asyncCall(callMessage, timeout);
03217 }
03218
03219 Q_SIGNALS:
03234 void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
03235
03236 protected:
03237 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03238 };
03239
03247 class TP_QT_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
03248 {
03249 Q_OBJECT
03250
03251 public:
03258 static inline QLatin1String staticInterfaceName()
03259 {
03260 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
03261 }
03262
03270 ConnectionInterfaceContactBlockingInterface(
03271 const QString& busName,
03272 const QString& objectPath,
03273 QObject* parent = 0
03274 );
03275
03284 ConnectionInterfaceContactBlockingInterface(
03285 const QDBusConnection& connection,
03286 const QString& busName,
03287 const QString& objectPath,
03288 QObject* parent = 0
03289 );
03290
03297 ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
03298
03306 explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
03307
03315 ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03316
03333 inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
03334 {
03335 return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
03336 }
03337
03344 Tp::PendingVariantMap *requestAllProperties() const
03345 {
03346 return internalRequestAllProperties();
03347 }
03348
03349 public Q_SLOTS:
03409 inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
03410 {
03411 if (!invalidationReason().isEmpty()) {
03412 return QDBusPendingReply<>(QDBusMessage::createError(
03413 invalidationReason(),
03414 invalidationMessage()
03415 ));
03416 }
03417
03418 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03419 this->staticInterfaceName(), QLatin1String("BlockContacts"));
03420 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
03421 return this->connection().asyncCall(callMessage, timeout);
03422 }
03423
03442 inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
03443 {
03444 if (!invalidationReason().isEmpty()) {
03445 return QDBusPendingReply<>(QDBusMessage::createError(
03446 invalidationReason(),
03447 invalidationMessage()
03448 ));
03449 }
03450
03451 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03452 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
03453 callMessage << QVariant::fromValue(contacts);
03454 return this->connection().asyncCall(callMessage, timeout);
03455 }
03456
03477 inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
03478 {
03479 if (!invalidationReason().isEmpty()) {
03480 return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
03481 invalidationReason(),
03482 invalidationMessage()
03483 ));
03484 }
03485
03486 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03487 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
03488 return this->connection().asyncCall(callMessage, timeout);
03489 }
03490
03491 Q_SIGNALS:
03510 void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
03511
03512 protected:
03513 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03514 };
03515
03523 class TP_QT_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
03524 {
03525 Q_OBJECT
03526
03527 public:
03534 static inline QLatin1String staticInterfaceName()
03535 {
03536 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
03537 }
03538
03546 ConnectionInterfaceContactCapabilitiesInterface(
03547 const QString& busName,
03548 const QString& objectPath,
03549 QObject* parent = 0
03550 );
03551
03560 ConnectionInterfaceContactCapabilitiesInterface(
03561 const QDBusConnection& connection,
03562 const QString& busName,
03563 const QString& objectPath,
03564 QObject* parent = 0
03565 );
03566
03573 ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
03574
03582 explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
03583
03591 ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03592
03599 Tp::PendingVariantMap *requestAllProperties() const
03600 {
03601 return internalRequestAllProperties();
03602 }
03603
03604 public Q_SLOTS:
03667 inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
03668 {
03669 if (!invalidationReason().isEmpty()) {
03670 return QDBusPendingReply<>(QDBusMessage::createError(
03671 invalidationReason(),
03672 invalidationMessage()
03673 ));
03674 }
03675
03676 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03677 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
03678 callMessage << QVariant::fromValue(handlerCapabilities);
03679 return this->connection().asyncCall(callMessage, timeout);
03680 }
03681
03717 inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
03718 {
03719 if (!invalidationReason().isEmpty()) {
03720 return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
03721 invalidationReason(),
03722 invalidationMessage()
03723 ));
03724 }
03725
03726 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03727 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
03728 callMessage << QVariant::fromValue(handles);
03729 return this->connection().asyncCall(callMessage, timeout);
03730 }
03731
03732 Q_SIGNALS:
03753 void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
03754
03755 protected:
03756 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03757 };
03758
03766 class TP_QT_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
03767 {
03768 Q_OBJECT
03769
03770 public:
03777 static inline QLatin1String staticInterfaceName()
03778 {
03779 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
03780 }
03781
03789 ConnectionInterfaceContactGroupsInterface(
03790 const QString& busName,
03791 const QString& objectPath,
03792 QObject* parent = 0
03793 );
03794
03803 ConnectionInterfaceContactGroupsInterface(
03804 const QDBusConnection& connection,
03805 const QString& busName,
03806 const QString& objectPath,
03807 QObject* parent = 0
03808 );
03809
03816 ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
03817
03825 explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03826
03834 ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03835
03852 inline Tp::PendingVariant *requestPropertyDisjointGroups() const
03853 {
03854 return internalRequestProperty(QLatin1String("DisjointGroups"));
03855 }
03856
03869 inline Tp::PendingVariant *requestPropertyGroupStorage() const
03870 {
03871 return internalRequestProperty(QLatin1String("GroupStorage"));
03872 }
03873
03897 inline Tp::PendingVariant *requestPropertyGroups() const
03898 {
03899 return internalRequestProperty(QLatin1String("Groups"));
03900 }
03901
03908 Tp::PendingVariantMap *requestAllProperties() const
03909 {
03910 return internalRequestAllProperties();
03911 }
03912
03913 public Q_SLOTS:
03962 inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
03963 {
03964 if (!invalidationReason().isEmpty()) {
03965 return QDBusPendingReply<>(QDBusMessage::createError(
03966 invalidationReason(),
03967 invalidationMessage()
03968 ));
03969 }
03970
03971 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03972 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
03973 callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
03974 return this->connection().asyncCall(callMessage, timeout);
03975 }
03976
04024 inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
04025 {
04026 if (!invalidationReason().isEmpty()) {
04027 return QDBusPendingReply<>(QDBusMessage::createError(
04028 invalidationReason(),
04029 invalidationMessage()
04030 ));
04031 }
04032
04033 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04034 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
04035 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
04036 return this->connection().asyncCall(callMessage, timeout);
04037 }
04038
04079 inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
04080 {
04081 if (!invalidationReason().isEmpty()) {
04082 return QDBusPendingReply<>(QDBusMessage::createError(
04083 invalidationReason(),
04084 invalidationMessage()
04085 ));
04086 }
04087
04088 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04089 this->staticInterfaceName(), QLatin1String("AddToGroup"));
04090 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
04091 return this->connection().asyncCall(callMessage, timeout);
04092 }
04093
04133 inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
04134 {
04135 if (!invalidationReason().isEmpty()) {
04136 return QDBusPendingReply<>(QDBusMessage::createError(
04137 invalidationReason(),
04138 invalidationMessage()
04139 ));
04140 }
04141
04142 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04143 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
04144 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
04145 return this->connection().asyncCall(callMessage, timeout);
04146 }
04147
04176 inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
04177 {
04178 if (!invalidationReason().isEmpty()) {
04179 return QDBusPendingReply<>(QDBusMessage::createError(
04180 invalidationReason(),
04181 invalidationMessage()
04182 ));
04183 }
04184
04185 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04186 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
04187 callMessage << QVariant::fromValue(group);
04188 return this->connection().asyncCall(callMessage, timeout);
04189 }
04190
04230 inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
04231 {
04232 if (!invalidationReason().isEmpty()) {
04233 return QDBusPendingReply<>(QDBusMessage::createError(
04234 invalidationReason(),
04235 invalidationMessage()
04236 ));
04237 }
04238
04239 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04240 this->staticInterfaceName(), QLatin1String("RenameGroup"));
04241 callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
04242 return this->connection().asyncCall(callMessage, timeout);
04243 }
04244
04245 Q_SIGNALS:
04263 void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
04264
04275 void GroupsCreated(const QStringList& names);
04276
04324 void GroupRenamed(const QString& oldName, const QString& newName);
04325
04352 void GroupsRemoved(const QStringList& names);
04353
04354 protected:
04355 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04356 };
04357
04365 class TP_QT_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
04366 {
04367 Q_OBJECT
04368
04369 public:
04376 static inline QLatin1String staticInterfaceName()
04377 {
04378 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
04379 }
04380
04388 ConnectionInterfaceContactInfoInterface(
04389 const QString& busName,
04390 const QString& objectPath,
04391 QObject* parent = 0
04392 );
04393
04402 ConnectionInterfaceContactInfoInterface(
04403 const QDBusConnection& connection,
04404 const QString& busName,
04405 const QString& objectPath,
04406 QObject* parent = 0
04407 );
04408
04415 ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
04416
04424 explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
04425
04433 ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04434
04458 inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
04459 {
04460 return internalRequestProperty(QLatin1String("ContactInfoFlags"));
04461 }
04462
04520 inline Tp::PendingVariant *requestPropertySupportedFields() const
04521 {
04522 return internalRequestProperty(QLatin1String("SupportedFields"));
04523 }
04524
04531 Tp::PendingVariantMap *requestAllProperties() const
04532 {
04533 return internalRequestAllProperties();
04534 }
04535
04536 public Q_SLOTS:
04559 inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04560 {
04561 if (!invalidationReason().isEmpty()) {
04562 return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
04563 invalidationReason(),
04564 invalidationMessage()
04565 ));
04566 }
04567
04568 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04569 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
04570 callMessage << QVariant::fromValue(contacts);
04571 return this->connection().asyncCall(callMessage, timeout);
04572 }
04573
04593 inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04594 {
04595 if (!invalidationReason().isEmpty()) {
04596 return QDBusPendingReply<>(QDBusMessage::createError(
04597 invalidationReason(),
04598 invalidationMessage()
04599 ));
04600 }
04601
04602 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04603 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
04604 callMessage << QVariant::fromValue(contacts);
04605 return this->connection().asyncCall(callMessage, timeout);
04606 }
04607
04629 inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
04630 {
04631 if (!invalidationReason().isEmpty()) {
04632 return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
04633 invalidationReason(),
04634 invalidationMessage()
04635 ));
04636 }
04637
04638 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04639 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
04640 callMessage << QVariant::fromValue(contact);
04641 return this->connection().asyncCall(callMessage, timeout);
04642 }
04643
04661 inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
04662 {
04663 if (!invalidationReason().isEmpty()) {
04664 return QDBusPendingReply<>(QDBusMessage::createError(
04665 invalidationReason(),
04666 invalidationMessage()
04667 ));
04668 }
04669
04670 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04671 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
04672 callMessage << QVariant::fromValue(contactInfo);
04673 return this->connection().asyncCall(callMessage, timeout);
04674 }
04675
04676 Q_SIGNALS:
04693 void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
04694
04695 protected:
04696 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04697 };
04698
04706 class TP_QT_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
04707 {
04708 Q_OBJECT
04709
04710 public:
04717 static inline QLatin1String staticInterfaceName()
04718 {
04719 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
04720 }
04721
04729 ConnectionInterfaceContactListInterface(
04730 const QString& busName,
04731 const QString& objectPath,
04732 QObject* parent = 0
04733 );
04734
04743 ConnectionInterfaceContactListInterface(
04744 const QDBusConnection& connection,
04745 const QString& busName,
04746 const QString& objectPath,
04747 QObject* parent = 0
04748 );
04749
04756 ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
04757
04765 explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
04766
04774 ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04775
04786 inline Tp::PendingVariant *requestPropertyContactListState() const
04787 {
04788 return internalRequestProperty(QLatin1String("ContactListState"));
04789 }
04790
04850 inline Tp::PendingVariant *requestPropertyContactListPersists() const
04851 {
04852 return internalRequestProperty(QLatin1String("ContactListPersists"));
04853 }
04854
04883 inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
04884 {
04885 return internalRequestProperty(QLatin1String("CanChangeContactList"));
04886 }
04887
04916 inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
04917 {
04918 return internalRequestProperty(QLatin1String("RequestUsesMessage"));
04919 }
04920
04952 inline Tp::PendingVariant *requestPropertyDownloadAtConnection() const
04953 {
04954 return internalRequestProperty(QLatin1String("DownloadAtConnection"));
04955 }
04956
04963 Tp::PendingVariantMap *requestAllProperties() const
04964 {
04965 return internalRequestAllProperties();
04966 }
04967
04968 public Q_SLOTS:
05040 inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
05041 {
05042 if (!invalidationReason().isEmpty()) {
05043 return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
05044 invalidationReason(),
05045 invalidationMessage()
05046 ));
05047 }
05048
05049 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05050 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
05051 callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
05052 return this->connection().asyncCall(callMessage, timeout);
05053 }
05054
05165 inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
05166 {
05167 if (!invalidationReason().isEmpty()) {
05168 return QDBusPendingReply<>(QDBusMessage::createError(
05169 invalidationReason(),
05170 invalidationMessage()
05171 ));
05172 }
05173
05174 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05175 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
05176 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
05177 return this->connection().asyncCall(callMessage, timeout);
05178 }
05179
05251 inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
05252 {
05253 if (!invalidationReason().isEmpty()) {
05254 return QDBusPendingReply<>(QDBusMessage::createError(
05255 invalidationReason(),
05256 invalidationMessage()
05257 ));
05258 }
05259
05260 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05261 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
05262 callMessage << QVariant::fromValue(contacts);
05263 return this->connection().asyncCall(callMessage, timeout);
05264 }
05265
05315 inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
05316 {
05317 if (!invalidationReason().isEmpty()) {
05318 return QDBusPendingReply<>(QDBusMessage::createError(
05319 invalidationReason(),
05320 invalidationMessage()
05321 ));
05322 }
05323
05324 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05325 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
05326 callMessage << QVariant::fromValue(contacts);
05327 return this->connection().asyncCall(callMessage, timeout);
05328 }
05329
05366 inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
05367 {
05368 if (!invalidationReason().isEmpty()) {
05369 return QDBusPendingReply<>(QDBusMessage::createError(
05370 invalidationReason(),
05371 invalidationMessage()
05372 ));
05373 }
05374
05375 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05376 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
05377 callMessage << QVariant::fromValue(contacts);
05378 return this->connection().asyncCall(callMessage, timeout);
05379 }
05380
05417 inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
05418 {
05419 if (!invalidationReason().isEmpty()) {
05420 return QDBusPendingReply<>(QDBusMessage::createError(
05421 invalidationReason(),
05422 invalidationMessage()
05423 ));
05424 }
05425
05426 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05427 this->staticInterfaceName(), QLatin1String("Unpublish"));
05428 callMessage << QVariant::fromValue(contacts);
05429 return this->connection().asyncCall(callMessage, timeout);
05430 }
05431
05446 inline QDBusPendingReply<> Download(int timeout = -1)
05447 {
05448 if (!invalidationReason().isEmpty()) {
05449 return QDBusPendingReply<>(QDBusMessage::createError(
05450 invalidationReason(),
05451 invalidationMessage()
05452 ));
05453 }
05454
05455 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05456 this->staticInterfaceName(), QLatin1String("Download"));
05457 return this->connection().asyncCall(callMessage, timeout);
05458 }
05459
05460 Q_SIGNALS:
05470 void ContactListStateChanged(uint contactListState);
05471
05522 void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
05523
05546 void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
05547
05548 protected:
05549 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05550 };
05551
05559 class TP_QT_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
05560 {
05561 Q_OBJECT
05562
05563 public:
05570 static inline QLatin1String staticInterfaceName()
05571 {
05572 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
05573 }
05574
05582 ConnectionInterfaceContactsInterface(
05583 const QString& busName,
05584 const QString& objectPath,
05585 QObject* parent = 0
05586 );
05587
05596 ConnectionInterfaceContactsInterface(
05597 const QDBusConnection& connection,
05598 const QString& busName,
05599 const QString& objectPath,
05600 QObject* parent = 0
05601 );
05602
05609 ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
05610
05618 explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
05619
05627 ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05628
05639 inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
05640 {
05641 return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
05642 }
05643
05650 Tp::PendingVariantMap *requestAllProperties() const
05651 {
05652 return internalRequestAllProperties();
05653 }
05654
05655 public Q_SLOTS:
05738 inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
05739 {
05740 if (!invalidationReason().isEmpty()) {
05741 return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
05742 invalidationReason(),
05743 invalidationMessage()
05744 ));
05745 }
05746
05747 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05748 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
05749 callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
05750 return this->connection().asyncCall(callMessage, timeout);
05751 }
05752
05801 inline QDBusPendingReply<uint, QVariantMap> GetContactByID(const QString& identifier, const QStringList& interfaces, int timeout = -1)
05802 {
05803 if (!invalidationReason().isEmpty()) {
05804 return QDBusPendingReply<uint, QVariantMap>(QDBusMessage::createError(
05805 invalidationReason(),
05806 invalidationMessage()
05807 ));
05808 }
05809
05810 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05811 this->staticInterfaceName(), QLatin1String("GetContactByID"));
05812 callMessage << QVariant::fromValue(identifier) << QVariant::fromValue(interfaces);
05813 return this->connection().asyncCall(callMessage, timeout);
05814 }
05815
05816 protected:
05817 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05818 };
05819
05827 class TP_QT_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
05828 {
05829 Q_OBJECT
05830
05831 public:
05838 static inline QLatin1String staticInterfaceName()
05839 {
05840 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
05841 }
05842
05850 ConnectionInterfaceLocationInterface(
05851 const QString& busName,
05852 const QString& objectPath,
05853 QObject* parent = 0
05854 );
05855
05864 ConnectionInterfaceLocationInterface(
05865 const QDBusConnection& connection,
05866 const QString& busName,
05867 const QString& objectPath,
05868 QObject* parent = 0
05869 );
05870
05877 ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
05878
05886 explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05887
05895 ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05896
05906 inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
05907 {
05908 return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
05909 }
05910
05923 inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
05924 {
05925 return internalRequestProperty(QLatin1String("LocationAccessControl"));
05926 }
05927
05940 inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
05941 {
05942 return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
05943 }
05944
05958 inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
05959 {
05960 return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
05961 }
05962
05969 Tp::PendingVariantMap *requestAllProperties() const
05970 {
05971 return internalRequestAllProperties();
05972 }
05973
05974 public Q_SLOTS:
06015 inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
06016 {
06017 if (!invalidationReason().isEmpty()) {
06018 return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
06019 invalidationReason(),
06020 invalidationMessage()
06021 ));
06022 }
06023
06024 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06025 this->staticInterfaceName(), QLatin1String("GetLocations"));
06026 callMessage << QVariant::fromValue(contacts);
06027 return this->connection().asyncCall(callMessage, timeout);
06028 }
06029
06054 inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
06055 {
06056 if (!invalidationReason().isEmpty()) {
06057 return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
06058 invalidationReason(),
06059 invalidationMessage()
06060 ));
06061 }
06062
06063 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06064 this->staticInterfaceName(), QLatin1String("RequestLocation"));
06065 callMessage << QVariant::fromValue(contact);
06066 return this->connection().asyncCall(callMessage, timeout);
06067 }
06068
06090 inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
06091 {
06092 if (!invalidationReason().isEmpty()) {
06093 return QDBusPendingReply<>(QDBusMessage::createError(
06094 invalidationReason(),
06095 invalidationMessage()
06096 ));
06097 }
06098
06099 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06100 this->staticInterfaceName(), QLatin1String("SetLocation"));
06101 callMessage << QVariant::fromValue(location);
06102 return this->connection().asyncCall(callMessage, timeout);
06103 }
06104
06105 Q_SIGNALS:
06120 void LocationUpdated(uint contact, const QVariantMap& location);
06121
06122 protected:
06123 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06124 };
06125
06133 class TP_QT_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
06134 {
06135 Q_OBJECT
06136
06137 public:
06144 static inline QLatin1String staticInterfaceName()
06145 {
06146 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
06147 }
06148
06156 ConnectionInterfaceMailNotificationInterface(
06157 const QString& busName,
06158 const QString& objectPath,
06159 QObject* parent = 0
06160 );
06161
06170 ConnectionInterfaceMailNotificationInterface(
06171 const QDBusConnection& connection,
06172 const QString& busName,
06173 const QString& objectPath,
06174 QObject* parent = 0
06175 );
06176
06183 ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
06184
06192 explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
06193
06201 ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06202
06217 inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
06218 {
06219 return internalRequestProperty(QLatin1String("MailNotificationFlags"));
06220 }
06221
06246 inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
06247 {
06248 return internalRequestProperty(QLatin1String("UnreadMailCount"));
06249 }
06250
06267 inline Tp::PendingVariant *requestPropertyUnreadMails() const
06268 {
06269 return internalRequestProperty(QLatin1String("UnreadMails"));
06270 }
06271
06286 inline Tp::PendingVariant *requestPropertyMailAddress() const
06287 {
06288 return internalRequestProperty(QLatin1String("MailAddress"));
06289 }
06290
06297 Tp::PendingVariantMap *requestAllProperties() const
06298 {
06299 return internalRequestAllProperties();
06300 }
06301
06302 public Q_SLOTS:
06326 inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
06327 {
06328 if (!invalidationReason().isEmpty()) {
06329 return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
06330 invalidationReason(),
06331 invalidationMessage()
06332 ));
06333 }
06334
06335 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06336 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
06337 return this->connection().asyncCall(callMessage, timeout);
06338 }
06339
06369 inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
06370 {
06371 if (!invalidationReason().isEmpty()) {
06372 return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
06373 invalidationReason(),
06374 invalidationMessage()
06375 ));
06376 }
06377
06378 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06379 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
06380 callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
06381 return this->connection().asyncCall(callMessage, timeout);
06382 }
06383
06384 Q_SIGNALS:
06407 void MailsReceived(const Tp::MailList& mails);
06408
06450 void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
06451
06452 protected:
06453 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06454 };
06455
06463 class TP_QT_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
06464 {
06465 Q_OBJECT
06466
06467 public:
06474 static inline QLatin1String staticInterfaceName()
06475 {
06476 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
06477 }
06478
06486 ConnectionInterfacePowerSavingInterface(
06487 const QString& busName,
06488 const QString& objectPath,
06489 QObject* parent = 0
06490 );
06491
06500 ConnectionInterfacePowerSavingInterface(
06501 const QDBusConnection& connection,
06502 const QString& busName,
06503 const QString& objectPath,
06504 QObject* parent = 0
06505 );
06506
06513 ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
06514
06522 explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
06523
06531 ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06532
06548 inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
06549 {
06550 return internalRequestProperty(QLatin1String("PowerSavingActive"));
06551 }
06552
06559 Tp::PendingVariantMap *requestAllProperties() const
06560 {
06561 return internalRequestAllProperties();
06562 }
06563
06564 public Q_SLOTS:
06598 inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
06599 {
06600 if (!invalidationReason().isEmpty()) {
06601 return QDBusPendingReply<>(QDBusMessage::createError(
06602 invalidationReason(),
06603 invalidationMessage()
06604 ));
06605 }
06606
06607 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06608 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
06609 callMessage << QVariant::fromValue(activate);
06610 return this->connection().asyncCall(callMessage, timeout);
06611 }
06612
06613 Q_SIGNALS:
06626 void PowerSavingChanged(bool active);
06627
06628 protected:
06629 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06630 };
06631
06639 class TP_QT_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
06640 {
06641 Q_OBJECT
06642
06643 public:
06650 static inline QLatin1String staticInterfaceName()
06651 {
06652 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
06653 }
06654
06662 ConnectionInterfacePresenceInterface(
06663 const QString& busName,
06664 const QString& objectPath,
06665 QObject* parent = 0
06666 );
06667
06676 ConnectionInterfacePresenceInterface(
06677 const QDBusConnection& connection,
06678 const QString& busName,
06679 const QString& objectPath,
06680 QObject* parent = 0
06681 );
06682
06689 ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
06690
06698 explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06699
06707 ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06708
06715 Tp::PendingVariantMap *requestAllProperties() const
06716 {
06717 return internalRequestAllProperties();
06718 }
06719
06720 public Q_SLOTS:
06742 inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
06743 {
06744 if (!invalidationReason().isEmpty()) {
06745 return QDBusPendingReply<>(QDBusMessage::createError(
06746 invalidationReason(),
06747 invalidationMessage()
06748 ));
06749 }
06750
06751 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06752 this->staticInterfaceName(), QLatin1String("AddStatus"));
06753 callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
06754 return this->connection().asyncCall(callMessage, timeout);
06755 }
06756
06770 inline QDBusPendingReply<> ClearStatus(int timeout = -1)
06771 {
06772 if (!invalidationReason().isEmpty()) {
06773 return QDBusPendingReply<>(QDBusMessage::createError(
06774 invalidationReason(),
06775 invalidationMessage()
06776 ));
06777 }
06778
06779 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06780 this->staticInterfaceName(), QLatin1String("ClearStatus"));
06781 return this->connection().asyncCall(callMessage, timeout);
06782 }
06783
06807 inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
06808 {
06809 if (!invalidationReason().isEmpty()) {
06810 return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
06811 invalidationReason(),
06812 invalidationMessage()
06813 ));
06814 }
06815
06816 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06817 this->staticInterfaceName(), QLatin1String("GetPresence"));
06818 callMessage << QVariant::fromValue(contacts);
06819 return this->connection().asyncCall(callMessage, timeout);
06820 }
06821
06843 inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
06844 {
06845 if (!invalidationReason().isEmpty()) {
06846 return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
06847 invalidationReason(),
06848 invalidationMessage()
06849 ));
06850 }
06851
06852 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06853 this->staticInterfaceName(), QLatin1String("GetStatuses"));
06854 return this->connection().asyncCall(callMessage, timeout);
06855 }
06856
06875 inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
06876 {
06877 if (!invalidationReason().isEmpty()) {
06878 return QDBusPendingReply<>(QDBusMessage::createError(
06879 invalidationReason(),
06880 invalidationMessage()
06881 ));
06882 }
06883
06884 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06885 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
06886 callMessage << QVariant::fromValue(status);
06887 return this->connection().asyncCall(callMessage, timeout);
06888 }
06889
06908 inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
06909 {
06910 if (!invalidationReason().isEmpty()) {
06911 return QDBusPendingReply<>(QDBusMessage::createError(
06912 invalidationReason(),
06913 invalidationMessage()
06914 ));
06915 }
06916
06917 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06918 this->staticInterfaceName(), QLatin1String("RequestPresence"));
06919 callMessage << QVariant::fromValue(contacts);
06920 return this->connection().asyncCall(callMessage, timeout);
06921 }
06922
06938 inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
06939 {
06940 if (!invalidationReason().isEmpty()) {
06941 return QDBusPendingReply<>(QDBusMessage::createError(
06942 invalidationReason(),
06943 invalidationMessage()
06944 ));
06945 }
06946
06947 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06948 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
06949 callMessage << QVariant::fromValue(time);
06950 return this->connection().asyncCall(callMessage, timeout);
06951 }
06952
06990 inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
06991 {
06992 if (!invalidationReason().isEmpty()) {
06993 return QDBusPendingReply<>(QDBusMessage::createError(
06994 invalidationReason(),
06995 invalidationMessage()
06996 ));
06997 }
06998
06999 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07000 this->staticInterfaceName(), QLatin1String("SetStatus"));
07001 callMessage << QVariant::fromValue(statuses);
07002 return this->connection().asyncCall(callMessage, timeout);
07003 }
07004
07005 Q_SIGNALS:
07022 void PresenceUpdate(const Tp::ContactPresences& presence);
07023
07024 protected:
07025 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07026 };
07027
07035 class TP_QT_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
07036 {
07037 Q_OBJECT
07038
07039 public:
07046 static inline QLatin1String staticInterfaceName()
07047 {
07048 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
07049 }
07050
07058 ConnectionInterfaceRequestsInterface(
07059 const QString& busName,
07060 const QString& objectPath,
07061 QObject* parent = 0
07062 );
07063
07072 ConnectionInterfaceRequestsInterface(
07073 const QDBusConnection& connection,
07074 const QString& busName,
07075 const QString& objectPath,
07076 QObject* parent = 0
07077 );
07078
07085 ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
07086
07094 explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
07095
07103 ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07104
07115 inline Tp::PendingVariant *requestPropertyChannels() const
07116 {
07117 return internalRequestProperty(QLatin1String("Channels"));
07118 }
07119
07149 inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
07150 {
07151 return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
07152 }
07153
07160 Tp::PendingVariantMap *requestAllProperties() const
07161 {
07162 return internalRequestAllProperties();
07163 }
07164
07165 public Q_SLOTS:
07247 inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
07248 {
07249 if (!invalidationReason().isEmpty()) {
07250 return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
07251 invalidationReason(),
07252 invalidationMessage()
07253 ));
07254 }
07255
07256 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07257 this->staticInterfaceName(), QLatin1String("CreateChannel"));
07258 callMessage << QVariant::fromValue(request);
07259 return this->connection().asyncCall(callMessage, timeout);
07260 }
07261
07326 inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
07327 {
07328 if (!invalidationReason().isEmpty()) {
07329 return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
07330 invalidationReason(),
07331 invalidationMessage()
07332 ));
07333 }
07334
07335 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07336 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
07337 callMessage << QVariant::fromValue(request);
07338 return this->connection().asyncCall(callMessage, timeout);
07339 }
07340
07341 Q_SIGNALS:
07385 void NewChannels(const Tp::ChannelDetailsList& channels);
07386
07399 void ChannelClosed(const QDBusObjectPath& removed);
07400
07401 protected:
07402 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07403 };
07404
07412 class TP_QT_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
07413 {
07414 Q_OBJECT
07415
07416 public:
07423 static inline QLatin1String staticInterfaceName()
07424 {
07425 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
07426 }
07427
07435 ConnectionInterfaceServicePointInterface(
07436 const QString& busName,
07437 const QString& objectPath,
07438 QObject* parent = 0
07439 );
07440
07449 ConnectionInterfaceServicePointInterface(
07450 const QDBusConnection& connection,
07451 const QString& busName,
07452 const QString& objectPath,
07453 QObject* parent = 0
07454 );
07455
07462 ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
07463
07471 explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
07472
07480 ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07481
07493 inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
07494 {
07495 return internalRequestProperty(QLatin1String("KnownServicePoints"));
07496 }
07497
07504 Tp::PendingVariantMap *requestAllProperties() const
07505 {
07506 return internalRequestAllProperties();
07507 }
07508
07509 Q_SIGNALS:
07523 void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
07524
07525 protected:
07526 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07527 };
07528
07536 class TP_QT_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
07537 {
07538 Q_OBJECT
07539
07540 public:
07547 static inline QLatin1String staticInterfaceName()
07548 {
07549 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
07550 }
07551
07559 ConnectionInterfaceSimplePresenceInterface(
07560 const QString& busName,
07561 const QString& objectPath,
07562 QObject* parent = 0
07563 );
07564
07573 ConnectionInterfaceSimplePresenceInterface(
07574 const QDBusConnection& connection,
07575 const QString& busName,
07576 const QString& objectPath,
07577 QObject* parent = 0
07578 );
07579
07586 ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
07587
07595 explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
07596
07604 ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07605
07647 inline Tp::PendingVariant *requestPropertyStatuses() const
07648 {
07649 return internalRequestProperty(QLatin1String("Statuses"));
07650 }
07651
07696 inline Tp::PendingVariant *requestPropertyMaximumStatusMessageLength() const
07697 {
07698 return internalRequestProperty(QLatin1String("MaximumStatusMessageLength"));
07699 }
07700
07707 Tp::PendingVariantMap *requestAllProperties() const
07708 {
07709 return internalRequestAllProperties();
07710 }
07711
07712 public Q_SLOTS:
07776 inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
07777 {
07778 if (!invalidationReason().isEmpty()) {
07779 return QDBusPendingReply<>(QDBusMessage::createError(
07780 invalidationReason(),
07781 invalidationMessage()
07782 ));
07783 }
07784
07785 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07786 this->staticInterfaceName(), QLatin1String("SetPresence"));
07787 callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
07788 return this->connection().asyncCall(callMessage, timeout);
07789 }
07790
07822 inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
07823 {
07824 if (!invalidationReason().isEmpty()) {
07825 return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
07826 invalidationReason(),
07827 invalidationMessage()
07828 ));
07829 }
07830
07831 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07832 this->staticInterfaceName(), QLatin1String("GetPresences"));
07833 callMessage << QVariant::fromValue(contacts);
07834 return this->connection().asyncCall(callMessage, timeout);
07835 }
07836
07837 Q_SIGNALS:
07850 void PresencesChanged(const Tp::SimpleContactPresences& presence);
07851
07852 protected:
07853 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07854 };
07855 }
07856 }
07857 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
07858 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAddressingInterface*)
07859 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
07860 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
07861 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
07862 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
07863 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
07864 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
07865 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
07866 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
07867 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
07868 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
07869 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
07870 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
07871 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
07872 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
07873 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
07874 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
07875 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
07876 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
07877 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
07878 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)