00001
00002
00003
00004
00005
00006
00007
00008 #ifndef IN_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011
00012 #include <TelepathyQt4/Types>
00013
00014 #include <QtGlobal>
00015
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019
00020 #include <QDBusPendingReply>
00021
00022 #include <TelepathyQt4/AbstractInterface>
00023 #include <TelepathyQt4/DBusProxy>
00024 #include <TelepathyQt4/Global>
00025
00026 namespace Tp
00027 {
00028 class PendingVariant;
00029 class PendingOperation;
00030 }
00031
00032 namespace Tp
00033 {
00034 namespace Client
00035 {
00036
00044 class TELEPATHY_QT4_EXPORT 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
00125 inline Tp::PendingVariant *requestPropertyInterfaces() const
00126 {
00127 return internalRequestProperty(QLatin1String("Interfaces"));
00128 }
00129
00143 inline Tp::PendingVariant *requestPropertySelfHandle() const
00144 {
00145 return internalRequestProperty(QLatin1String("SelfHandle"));
00146 }
00147
00164 inline Tp::PendingVariant *requestPropertyStatus() const
00165 {
00166 return internalRequestProperty(QLatin1String("Status"));
00167 }
00168
00181 inline Tp::PendingVariant *requestPropertyHasImmortalHandles() const
00182 {
00183 return internalRequestProperty(QLatin1String("HasImmortalHandles"));
00184 }
00185
00192 Tp::PendingVariantMap *requestAllProperties() const
00193 {
00194 return internalRequestAllProperties();
00195 }
00196
00197 public Q_SLOTS:
00213 inline QDBusPendingReply<> Connect(int timeout = -1)
00214 {
00215 if (!invalidationReason().isEmpty()) {
00216 return QDBusPendingReply<>(QDBusMessage::createError(
00217 invalidationReason(),
00218 invalidationMessage()
00219 ));
00220 }
00221
00222 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00223 this->staticInterfaceName(), QLatin1String("Connect"));
00224 return this->connection().asyncCall(callMessage, timeout);
00225 }
00226
00239 inline QDBusPendingReply<> Disconnect(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("Disconnect"));
00250 return this->connection().asyncCall(callMessage, timeout);
00251 }
00252
00269 inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00270 {
00271 if (!invalidationReason().isEmpty()) {
00272 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00273 invalidationReason(),
00274 invalidationMessage()
00275 ));
00276 }
00277
00278 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00279 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00280 return this->connection().asyncCall(callMessage, timeout);
00281 }
00282
00297 inline QDBusPendingReply<QString> GetProtocol(int timeout = -1)
00298 {
00299 if (!invalidationReason().isEmpty()) {
00300 return QDBusPendingReply<QString>(QDBusMessage::createError(
00301 invalidationReason(),
00302 invalidationMessage()
00303 ));
00304 }
00305
00306 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00307 this->staticInterfaceName(), QLatin1String("GetProtocol"));
00308 return this->connection().asyncCall(callMessage, timeout);
00309 }
00310
00326 inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
00327 {
00328 if (!invalidationReason().isEmpty()) {
00329 return QDBusPendingReply<uint>(QDBusMessage::createError(
00330 invalidationReason(),
00331 invalidationMessage()
00332 ));
00333 }
00334
00335 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00336 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
00337 return this->connection().asyncCall(callMessage, timeout);
00338 }
00339
00354 inline QDBusPendingReply<uint> GetStatus(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("GetStatus"));
00365 return this->connection().asyncCall(callMessage, timeout);
00366 }
00367
00408 inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00409 {
00410 if (!invalidationReason().isEmpty()) {
00411 return QDBusPendingReply<>(QDBusMessage::createError(
00412 invalidationReason(),
00413 invalidationMessage()
00414 ));
00415 }
00416
00417 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00418 this->staticInterfaceName(), QLatin1String("HoldHandles"));
00419 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00420 return this->connection().asyncCall(callMessage, timeout);
00421 }
00422
00446 inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00447 {
00448 if (!invalidationReason().isEmpty()) {
00449 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00450 invalidationReason(),
00451 invalidationMessage()
00452 ));
00453 }
00454
00455 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00456 this->staticInterfaceName(), QLatin1String("InspectHandles"));
00457 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00458 return this->connection().asyncCall(callMessage, timeout);
00459 }
00460
00475 inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels(int timeout = -1)
00476 {
00477 if (!invalidationReason().isEmpty()) {
00478 return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00479 invalidationReason(),
00480 invalidationMessage()
00481 ));
00482 }
00483
00484 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00485 this->staticInterfaceName(), QLatin1String("ListChannels"));
00486 return this->connection().asyncCall(callMessage, timeout);
00487 }
00488
00514 inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00515 {
00516 if (!invalidationReason().isEmpty()) {
00517 return QDBusPendingReply<>(QDBusMessage::createError(
00518 invalidationReason(),
00519 invalidationMessage()
00520 ));
00521 }
00522
00523 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00524 this->staticInterfaceName(), QLatin1String("ReleaseHandles"));
00525 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00526 return this->connection().asyncCall(callMessage, timeout);
00527 }
00528
00606 inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler, int timeout = -1)
00607 {
00608 if (!invalidationReason().isEmpty()) {
00609 return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00610 invalidationReason(),
00611 invalidationMessage()
00612 ));
00613 }
00614
00615 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00616 this->staticInterfaceName(), QLatin1String("RequestChannel"));
00617 callMessage << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00618 return this->connection().asyncCall(callMessage, timeout);
00619 }
00620
00659 inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers, int timeout = -1)
00660 {
00661 if (!invalidationReason().isEmpty()) {
00662 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00663 invalidationReason(),
00664 invalidationMessage()
00665 ));
00666 }
00667
00668 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00669 this->staticInterfaceName(), QLatin1String("RequestHandles"));
00670 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
00671 return this->connection().asyncCall(callMessage, timeout);
00672 }
00673
00763 inline QDBusPendingReply<> AddClientInterest(const QStringList& tokens, int timeout = -1)
00764 {
00765 if (!invalidationReason().isEmpty()) {
00766 return QDBusPendingReply<>(QDBusMessage::createError(
00767 invalidationReason(),
00768 invalidationMessage()
00769 ));
00770 }
00771
00772 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00773 this->staticInterfaceName(), QLatin1String("AddClientInterest"));
00774 callMessage << QVariant::fromValue(tokens);
00775 return this->connection().asyncCall(callMessage, timeout);
00776 }
00777
00805 inline QDBusPendingReply<> RemoveClientInterest(const QStringList& tokens, int timeout = -1)
00806 {
00807 if (!invalidationReason().isEmpty()) {
00808 return QDBusPendingReply<>(QDBusMessage::createError(
00809 invalidationReason(),
00810 invalidationMessage()
00811 ));
00812 }
00813
00814 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00815 this->staticInterfaceName(), QLatin1String("RemoveClientInterest"));
00816 callMessage << QVariant::fromValue(tokens);
00817 return this->connection().asyncCall(callMessage, timeout);
00818 }
00819
00820 Q_SIGNALS:
00832 void SelfHandleChanged(uint selfHandle);
00833
00875 void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00876
00942 void ConnectionError(const QString& error, const QVariantMap& details);
00943
00960 void StatusChanged(uint status, uint reason);
00961
00962 protected:
00963 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00964 };
00965
00973 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00974 {
00975 Q_OBJECT
00976
00977 public:
00984 static inline QLatin1String staticInterfaceName()
00985 {
00986 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
00987 }
00988
00996 ConnectionInterfaceAliasingInterface(
00997 const QString& busName,
00998 const QString& objectPath,
00999 QObject* parent = 0
01000 );
01001
01010 ConnectionInterfaceAliasingInterface(
01011 const QDBusConnection& connection,
01012 const QString& busName,
01013 const QString& objectPath,
01014 QObject* parent = 0
01015 );
01016
01023 ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
01024
01032 explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
01033
01041 ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01042
01049 Tp::PendingVariantMap *requestAllProperties() const
01050 {
01051 return internalRequestAllProperties();
01052 }
01053
01054 public Q_SLOTS:
01070 inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
01071 {
01072 if (!invalidationReason().isEmpty()) {
01073 return QDBusPendingReply<uint>(QDBusMessage::createError(
01074 invalidationReason(),
01075 invalidationMessage()
01076 ));
01077 }
01078
01079 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01080 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
01081 return this->connection().asyncCall(callMessage, timeout);
01082 }
01083
01102 inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
01103 {
01104 if (!invalidationReason().isEmpty()) {
01105 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01106 invalidationReason(),
01107 invalidationMessage()
01108 ));
01109 }
01110
01111 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01112 this->staticInterfaceName(), QLatin1String("RequestAliases"));
01113 callMessage << QVariant::fromValue(contacts);
01114 return this->connection().asyncCall(callMessage, timeout);
01115 }
01116
01139 inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
01140 {
01141 if (!invalidationReason().isEmpty()) {
01142 return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
01143 invalidationReason(),
01144 invalidationMessage()
01145 ));
01146 }
01147
01148 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01149 this->staticInterfaceName(), QLatin1String("GetAliases"));
01150 callMessage << QVariant::fromValue(contacts);
01151 return this->connection().asyncCall(callMessage, timeout);
01152 }
01153
01173 inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
01174 {
01175 if (!invalidationReason().isEmpty()) {
01176 return QDBusPendingReply<>(QDBusMessage::createError(
01177 invalidationReason(),
01178 invalidationMessage()
01179 ));
01180 }
01181
01182 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01183 this->staticInterfaceName(), QLatin1String("SetAliases"));
01184 callMessage << QVariant::fromValue(aliases);
01185 return this->connection().asyncCall(callMessage, timeout);
01186 }
01187
01188 Q_SIGNALS:
01203 void AliasesChanged(const Tp::AliasPairList& aliases);
01204
01205 protected:
01206 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01207 };
01208
01216 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
01217 {
01218 Q_OBJECT
01219
01220 public:
01227 static inline QLatin1String staticInterfaceName()
01228 {
01229 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
01230 }
01231
01239 ConnectionInterfaceAnonymityInterface(
01240 const QString& busName,
01241 const QString& objectPath,
01242 QObject* parent = 0
01243 );
01244
01253 ConnectionInterfaceAnonymityInterface(
01254 const QDBusConnection& connection,
01255 const QString& busName,
01256 const QString& objectPath,
01257 QObject* parent = 0
01258 );
01259
01266 ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
01267
01275 explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01276
01284 ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01285
01296 inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
01297 {
01298 return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
01299 }
01300
01316 inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
01317 {
01318 return internalRequestProperty(QLatin1String("AnonymityMandatory"));
01319 }
01320
01336 inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
01337 {
01338 return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
01339 }
01340
01353 inline Tp::PendingVariant *requestPropertyAnonymityModes() const
01354 {
01355 return internalRequestProperty(QLatin1String("AnonymityModes"));
01356 }
01357
01370 inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
01371 {
01372 return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
01373 }
01374
01381 Tp::PendingVariantMap *requestAllProperties() const
01382 {
01383 return internalRequestAllProperties();
01384 }
01385
01386 Q_SIGNALS:
01396 void AnonymityModesChanged(uint modes);
01397
01398 protected:
01399 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01400 };
01401
01409 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01410 {
01411 Q_OBJECT
01412
01413 public:
01420 static inline QLatin1String staticInterfaceName()
01421 {
01422 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
01423 }
01424
01432 ConnectionInterfaceAvatarsInterface(
01433 const QString& busName,
01434 const QString& objectPath,
01435 QObject* parent = 0
01436 );
01437
01446 ConnectionInterfaceAvatarsInterface(
01447 const QDBusConnection& connection,
01448 const QString& busName,
01449 const QString& objectPath,
01450 QObject* parent = 0
01451 );
01452
01459 ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01460
01468 explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01469
01477 ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01478
01490 inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
01491 {
01492 return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
01493 }
01494
01506 inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
01507 {
01508 return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
01509 }
01510
01522 inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
01523 {
01524 return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
01525 }
01526
01541 inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
01542 {
01543 return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
01544 }
01545
01558 inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
01559 {
01560 return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
01561 }
01562
01574 inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
01575 {
01576 return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
01577 }
01578
01590 inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
01591 {
01592 return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
01593 }
01594
01606 inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
01607 {
01608 return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
01609 }
01610
01617 Tp::PendingVariantMap *requestAllProperties() const
01618 {
01619 return internalRequestAllProperties();
01620 }
01621
01622 public Q_SLOTS:
01657 inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
01658 {
01659 if (!invalidationReason().isEmpty()) {
01660 return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01661 invalidationReason(),
01662 invalidationMessage()
01663 ));
01664 }
01665
01666 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01667 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
01668 return this->connection().asyncCall(callMessage, timeout);
01669 }
01670
01692 inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01693 {
01694 if (!invalidationReason().isEmpty()) {
01695 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01696 invalidationReason(),
01697 invalidationMessage()
01698 ));
01699 }
01700
01701 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01702 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
01703 callMessage << QVariant::fromValue(contacts);
01704 return this->connection().asyncCall(callMessage, timeout);
01705 }
01706
01734 inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01735 {
01736 if (!invalidationReason().isEmpty()) {
01737 return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01738 invalidationReason(),
01739 invalidationMessage()
01740 ));
01741 }
01742
01743 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01744 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
01745 callMessage << QVariant::fromValue(contacts);
01746 return this->connection().asyncCall(callMessage, timeout);
01747 }
01748
01773 inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
01774 {
01775 if (!invalidationReason().isEmpty()) {
01776 return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01777 invalidationReason(),
01778 invalidationMessage()
01779 ));
01780 }
01781
01782 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01783 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
01784 callMessage << QVariant::fromValue(contact);
01785 return this->connection().asyncCall(callMessage, timeout);
01786 }
01787
01806 inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
01807 {
01808 if (!invalidationReason().isEmpty()) {
01809 return QDBusPendingReply<>(QDBusMessage::createError(
01810 invalidationReason(),
01811 invalidationMessage()
01812 ));
01813 }
01814
01815 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01816 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
01817 callMessage << QVariant::fromValue(contacts);
01818 return this->connection().asyncCall(callMessage, timeout);
01819 }
01820
01844 inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
01845 {
01846 if (!invalidationReason().isEmpty()) {
01847 return QDBusPendingReply<QString>(QDBusMessage::createError(
01848 invalidationReason(),
01849 invalidationMessage()
01850 ));
01851 }
01852
01853 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01854 this->staticInterfaceName(), QLatin1String("SetAvatar"));
01855 callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01856 return this->connection().asyncCall(callMessage, timeout);
01857 }
01858
01869 inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
01870 {
01871 if (!invalidationReason().isEmpty()) {
01872 return QDBusPendingReply<>(QDBusMessage::createError(
01873 invalidationReason(),
01874 invalidationMessage()
01875 ));
01876 }
01877
01878 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01879 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
01880 return this->connection().asyncCall(callMessage, timeout);
01881 }
01882
01883 Q_SIGNALS:
01900 void AvatarUpdated(uint contact, const QString& newAvatarToken);
01901
01924 void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01925
01926 protected:
01927 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01928 };
01929
01937 class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01938 {
01939 Q_OBJECT
01940
01941 public:
01948 static inline QLatin1String staticInterfaceName()
01949 {
01950 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
01951 }
01952
01960 ConnectionInterfaceBalanceInterface(
01961 const QString& busName,
01962 const QString& objectPath,
01963 QObject* parent = 0
01964 );
01965
01974 ConnectionInterfaceBalanceInterface(
01975 const QDBusConnection& connection,
01976 const QString& busName,
01977 const QString& objectPath,
01978 QObject* parent = 0
01979 );
01980
01987 ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
01988
01996 explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01997
02005 ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02006
02023 inline Tp::PendingVariant *requestPropertyAccountBalance() const
02024 {
02025 return internalRequestProperty(QLatin1String("AccountBalance"));
02026 }
02027
02034 Tp::PendingVariantMap *requestAllProperties() const
02035 {
02036 return internalRequestAllProperties();
02037 }
02038
02039 Q_SIGNALS:
02050 void BalanceChanged(const Tp::CurrencyAmount& balance);
02051
02052 protected:
02053 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02054 };
02055
02063 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
02064 {
02065 Q_OBJECT
02066
02067 public:
02074 static inline QLatin1String staticInterfaceName()
02075 {
02076 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
02077 }
02078
02086 ConnectionInterfaceCapabilitiesInterface(
02087 const QString& busName,
02088 const QString& objectPath,
02089 QObject* parent = 0
02090 );
02091
02100 ConnectionInterfaceCapabilitiesInterface(
02101 const QDBusConnection& connection,
02102 const QString& busName,
02103 const QString& objectPath,
02104 QObject* parent = 0
02105 );
02106
02113 ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
02114
02122 explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02123
02131 ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02132
02139 Tp::PendingVariantMap *requestAllProperties() const
02140 {
02141 return internalRequestAllProperties();
02142 }
02143
02144 public Q_SLOTS:
02194 inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
02195 {
02196 if (!invalidationReason().isEmpty()) {
02197 return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
02198 invalidationReason(),
02199 invalidationMessage()
02200 ));
02201 }
02202
02203 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02204 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
02205 callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
02206 return this->connection().asyncCall(callMessage, timeout);
02207 }
02208
02239 inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
02240 {
02241 if (!invalidationReason().isEmpty()) {
02242 return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
02243 invalidationReason(),
02244 invalidationMessage()
02245 ));
02246 }
02247
02248 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02249 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
02250 callMessage << QVariant::fromValue(handles);
02251 return this->connection().asyncCall(callMessage, timeout);
02252 }
02253
02254 Q_SIGNALS:
02277 void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
02278
02279 protected:
02280 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02281 };
02282
02290 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
02291 {
02292 Q_OBJECT
02293
02294 public:
02301 static inline QLatin1String staticInterfaceName()
02302 {
02303 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
02304 }
02305
02313 ConnectionInterfaceCellularInterface(
02314 const QString& busName,
02315 const QString& objectPath,
02316 QObject* parent = 0
02317 );
02318
02327 ConnectionInterfaceCellularInterface(
02328 const QDBusConnection& connection,
02329 const QString& busName,
02330 const QString& objectPath,
02331 QObject* parent = 0
02332 );
02333
02340 ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02341
02349 explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02350
02358 ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02359
02376 inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
02377 {
02378 return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
02379 }
02380
02397 inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
02398 {
02399 return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
02400 }
02401
02422 inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
02423 {
02424 return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
02425 }
02426
02447 inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
02448 {
02449 return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
02450 }
02451
02466 inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
02467 {
02468 return internalRequestProperty(QLatin1String("MessageServiceCentre"));
02469 }
02470
02485 inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
02486 {
02487 return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
02488 }
02489
02501 inline Tp::PendingVariant *requestPropertyIMSI() const
02502 {
02503 return internalRequestProperty(QLatin1String("IMSI"));
02504 }
02505
02522 inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
02523 {
02524 return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
02525 }
02526
02543 inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
02544 {
02545 return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
02546 }
02547
02571 inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
02572 {
02573 return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
02574 }
02575
02599 inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
02600 {
02601 return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
02602 }
02603
02610 Tp::PendingVariantMap *requestAllProperties() const
02611 {
02612 return internalRequestAllProperties();
02613 }
02614
02615 Q_SIGNALS:
02631 void IMSIChanged(const QString& IMSI);
02632
02633 protected:
02634 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02635 };
02636
02644 class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
02645 {
02646 Q_OBJECT
02647
02648 public:
02655 static inline QLatin1String staticInterfaceName()
02656 {
02657 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
02658 }
02659
02667 ConnectionInterfaceClientTypesInterface(
02668 const QString& busName,
02669 const QString& objectPath,
02670 QObject* parent = 0
02671 );
02672
02681 ConnectionInterfaceClientTypesInterface(
02682 const QDBusConnection& connection,
02683 const QString& busName,
02684 const QString& objectPath,
02685 QObject* parent = 0
02686 );
02687
02694 ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
02695
02703 explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02704
02712 ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02713
02720 Tp::PendingVariantMap *requestAllProperties() const
02721 {
02722 return internalRequestAllProperties();
02723 }
02724
02725 public Q_SLOTS:
02754 inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
02755 {
02756 if (!invalidationReason().isEmpty()) {
02757 return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
02758 invalidationReason(),
02759 invalidationMessage()
02760 ));
02761 }
02762
02763 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02764 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
02765 callMessage << QVariant::fromValue(contacts);
02766 return this->connection().asyncCall(callMessage, timeout);
02767 }
02768
02793 inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
02794 {
02795 if (!invalidationReason().isEmpty()) {
02796 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02797 invalidationReason(),
02798 invalidationMessage()
02799 ));
02800 }
02801
02802 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02803 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
02804 callMessage << QVariant::fromValue(contact);
02805 return this->connection().asyncCall(callMessage, timeout);
02806 }
02807
02808 Q_SIGNALS:
02823 void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
02824
02825 protected:
02826 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02827 };
02828
02836 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
02837 {
02838 Q_OBJECT
02839
02840 public:
02847 static inline QLatin1String staticInterfaceName()
02848 {
02849 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
02850 }
02851
02859 ConnectionInterfaceContactBlockingInterface(
02860 const QString& busName,
02861 const QString& objectPath,
02862 QObject* parent = 0
02863 );
02864
02873 ConnectionInterfaceContactBlockingInterface(
02874 const QDBusConnection& connection,
02875 const QString& busName,
02876 const QString& objectPath,
02877 QObject* parent = 0
02878 );
02879
02886 ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
02887
02895 explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
02896
02904 ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02905
02920 inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
02921 {
02922 return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
02923 }
02924
02931 Tp::PendingVariantMap *requestAllProperties() const
02932 {
02933 return internalRequestAllProperties();
02934 }
02935
02936 public Q_SLOTS:
02992 inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
02993 {
02994 if (!invalidationReason().isEmpty()) {
02995 return QDBusPendingReply<>(QDBusMessage::createError(
02996 invalidationReason(),
02997 invalidationMessage()
02998 ));
02999 }
03000
03001 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03002 this->staticInterfaceName(), QLatin1String("BlockContacts"));
03003 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
03004 return this->connection().asyncCall(callMessage, timeout);
03005 }
03006
03023 inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
03024 {
03025 if (!invalidationReason().isEmpty()) {
03026 return QDBusPendingReply<>(QDBusMessage::createError(
03027 invalidationReason(),
03028 invalidationMessage()
03029 ));
03030 }
03031
03032 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03033 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
03034 callMessage << QVariant::fromValue(contacts);
03035 return this->connection().asyncCall(callMessage, timeout);
03036 }
03037
03056 inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
03057 {
03058 if (!invalidationReason().isEmpty()) {
03059 return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
03060 invalidationReason(),
03061 invalidationMessage()
03062 ));
03063 }
03064
03065 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03066 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
03067 return this->connection().asyncCall(callMessage, timeout);
03068 }
03069
03070 Q_SIGNALS:
03087 void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
03088
03089 protected:
03090 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03091 };
03092
03100 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
03101 {
03102 Q_OBJECT
03103
03104 public:
03111 static inline QLatin1String staticInterfaceName()
03112 {
03113 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
03114 }
03115
03123 ConnectionInterfaceContactCapabilitiesInterface(
03124 const QString& busName,
03125 const QString& objectPath,
03126 QObject* parent = 0
03127 );
03128
03137 ConnectionInterfaceContactCapabilitiesInterface(
03138 const QDBusConnection& connection,
03139 const QString& busName,
03140 const QString& objectPath,
03141 QObject* parent = 0
03142 );
03143
03150 ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
03151
03159 explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
03160
03168 ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03169
03176 Tp::PendingVariantMap *requestAllProperties() const
03177 {
03178 return internalRequestAllProperties();
03179 }
03180
03181 public Q_SLOTS:
03242 inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
03243 {
03244 if (!invalidationReason().isEmpty()) {
03245 return QDBusPendingReply<>(QDBusMessage::createError(
03246 invalidationReason(),
03247 invalidationMessage()
03248 ));
03249 }
03250
03251 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03252 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
03253 callMessage << QVariant::fromValue(handlerCapabilities);
03254 return this->connection().asyncCall(callMessage, timeout);
03255 }
03256
03286 inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
03287 {
03288 if (!invalidationReason().isEmpty()) {
03289 return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
03290 invalidationReason(),
03291 invalidationMessage()
03292 ));
03293 }
03294
03295 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03296 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
03297 callMessage << QVariant::fromValue(handles);
03298 return this->connection().asyncCall(callMessage, timeout);
03299 }
03300
03301 Q_SIGNALS:
03318 void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
03319
03320 protected:
03321 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03322 };
03323
03331 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
03332 {
03333 Q_OBJECT
03334
03335 public:
03342 static inline QLatin1String staticInterfaceName()
03343 {
03344 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
03345 }
03346
03354 ConnectionInterfaceContactGroupsInterface(
03355 const QString& busName,
03356 const QString& objectPath,
03357 QObject* parent = 0
03358 );
03359
03368 ConnectionInterfaceContactGroupsInterface(
03369 const QDBusConnection& connection,
03370 const QString& busName,
03371 const QString& objectPath,
03372 QObject* parent = 0
03373 );
03374
03381 ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
03382
03390 explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03391
03399 ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03400
03415 inline Tp::PendingVariant *requestPropertyDisjointGroups() const
03416 {
03417 return internalRequestProperty(QLatin1String("DisjointGroups"));
03418 }
03419
03432 inline Tp::PendingVariant *requestPropertyGroupStorage() const
03433 {
03434 return internalRequestProperty(QLatin1String("GroupStorage"));
03435 }
03436
03458 inline Tp::PendingVariant *requestPropertyGroups() const
03459 {
03460 return internalRequestProperty(QLatin1String("Groups"));
03461 }
03462
03469 Tp::PendingVariantMap *requestAllProperties() const
03470 {
03471 return internalRequestAllProperties();
03472 }
03473
03474 public Q_SLOTS:
03521 inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
03522 {
03523 if (!invalidationReason().isEmpty()) {
03524 return QDBusPendingReply<>(QDBusMessage::createError(
03525 invalidationReason(),
03526 invalidationMessage()
03527 ));
03528 }
03529
03530 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03531 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
03532 callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
03533 return this->connection().asyncCall(callMessage, timeout);
03534 }
03535
03581 inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
03582 {
03583 if (!invalidationReason().isEmpty()) {
03584 return QDBusPendingReply<>(QDBusMessage::createError(
03585 invalidationReason(),
03586 invalidationMessage()
03587 ));
03588 }
03589
03590 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03591 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
03592 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03593 return this->connection().asyncCall(callMessage, timeout);
03594 }
03595
03634 inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03635 {
03636 if (!invalidationReason().isEmpty()) {
03637 return QDBusPendingReply<>(QDBusMessage::createError(
03638 invalidationReason(),
03639 invalidationMessage()
03640 ));
03641 }
03642
03643 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03644 this->staticInterfaceName(), QLatin1String("AddToGroup"));
03645 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03646 return this->connection().asyncCall(callMessage, timeout);
03647 }
03648
03686 inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03687 {
03688 if (!invalidationReason().isEmpty()) {
03689 return QDBusPendingReply<>(QDBusMessage::createError(
03690 invalidationReason(),
03691 invalidationMessage()
03692 ));
03693 }
03694
03695 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03696 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
03697 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03698 return this->connection().asyncCall(callMessage, timeout);
03699 }
03700
03727 inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
03728 {
03729 if (!invalidationReason().isEmpty()) {
03730 return QDBusPendingReply<>(QDBusMessage::createError(
03731 invalidationReason(),
03732 invalidationMessage()
03733 ));
03734 }
03735
03736 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03737 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
03738 callMessage << QVariant::fromValue(group);
03739 return this->connection().asyncCall(callMessage, timeout);
03740 }
03741
03779 inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
03780 {
03781 if (!invalidationReason().isEmpty()) {
03782 return QDBusPendingReply<>(QDBusMessage::createError(
03783 invalidationReason(),
03784 invalidationMessage()
03785 ));
03786 }
03787
03788 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03789 this->staticInterfaceName(), QLatin1String("RenameGroup"));
03790 callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
03791 return this->connection().asyncCall(callMessage, timeout);
03792 }
03793
03794 Q_SIGNALS:
03812 void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
03813
03824 void GroupsCreated(const QStringList& names);
03825
03871 void GroupRenamed(const QString& oldName, const QString& newName);
03872
03897 void GroupsRemoved(const QStringList& names);
03898
03899 protected:
03900 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03901 };
03902
03910 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
03911 {
03912 Q_OBJECT
03913
03914 public:
03921 static inline QLatin1String staticInterfaceName()
03922 {
03923 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
03924 }
03925
03933 ConnectionInterfaceContactInfoInterface(
03934 const QString& busName,
03935 const QString& objectPath,
03936 QObject* parent = 0
03937 );
03938
03947 ConnectionInterfaceContactInfoInterface(
03948 const QDBusConnection& connection,
03949 const QString& busName,
03950 const QString& objectPath,
03951 QObject* parent = 0
03952 );
03953
03960 ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
03961
03969 explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
03970
03978 ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03979
04001 inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
04002 {
04003 return internalRequestProperty(QLatin1String("ContactInfoFlags"));
04004 }
04005
04061 inline Tp::PendingVariant *requestPropertySupportedFields() const
04062 {
04063 return internalRequestProperty(QLatin1String("SupportedFields"));
04064 }
04065
04072 Tp::PendingVariantMap *requestAllProperties() const
04073 {
04074 return internalRequestAllProperties();
04075 }
04076
04077 public Q_SLOTS:
04100 inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04101 {
04102 if (!invalidationReason().isEmpty()) {
04103 return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
04104 invalidationReason(),
04105 invalidationMessage()
04106 ));
04107 }
04108
04109 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04110 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
04111 callMessage << QVariant::fromValue(contacts);
04112 return this->connection().asyncCall(callMessage, timeout);
04113 }
04114
04134 inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04135 {
04136 if (!invalidationReason().isEmpty()) {
04137 return QDBusPendingReply<>(QDBusMessage::createError(
04138 invalidationReason(),
04139 invalidationMessage()
04140 ));
04141 }
04142
04143 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04144 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
04145 callMessage << QVariant::fromValue(contacts);
04146 return this->connection().asyncCall(callMessage, timeout);
04147 }
04148
04170 inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
04171 {
04172 if (!invalidationReason().isEmpty()) {
04173 return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
04174 invalidationReason(),
04175 invalidationMessage()
04176 ));
04177 }
04178
04179 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04180 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
04181 callMessage << QVariant::fromValue(contact);
04182 return this->connection().asyncCall(callMessage, timeout);
04183 }
04184
04202 inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
04203 {
04204 if (!invalidationReason().isEmpty()) {
04205 return QDBusPendingReply<>(QDBusMessage::createError(
04206 invalidationReason(),
04207 invalidationMessage()
04208 ));
04209 }
04210
04211 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04212 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
04213 callMessage << QVariant::fromValue(contactInfo);
04214 return this->connection().asyncCall(callMessage, timeout);
04215 }
04216
04217 Q_SIGNALS:
04232 void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
04233
04234 protected:
04235 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04236 };
04237
04245 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
04246 {
04247 Q_OBJECT
04248
04249 public:
04256 static inline QLatin1String staticInterfaceName()
04257 {
04258 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
04259 }
04260
04268 ConnectionInterfaceContactListInterface(
04269 const QString& busName,
04270 const QString& objectPath,
04271 QObject* parent = 0
04272 );
04273
04282 ConnectionInterfaceContactListInterface(
04283 const QDBusConnection& connection,
04284 const QString& busName,
04285 const QString& objectPath,
04286 QObject* parent = 0
04287 );
04288
04295 ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
04296
04304 explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
04305
04313 ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04314
04325 inline Tp::PendingVariant *requestPropertyContactListState() const
04326 {
04327 return internalRequestProperty(QLatin1String("ContactListState"));
04328 }
04329
04387 inline Tp::PendingVariant *requestPropertyContactListPersists() const
04388 {
04389 return internalRequestProperty(QLatin1String("ContactListPersists"));
04390 }
04391
04418 inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
04419 {
04420 return internalRequestProperty(QLatin1String("CanChangeContactList"));
04421 }
04422
04449 inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
04450 {
04451 return internalRequestProperty(QLatin1String("RequestUsesMessage"));
04452 }
04453
04460 Tp::PendingVariantMap *requestAllProperties() const
04461 {
04462 return internalRequestAllProperties();
04463 }
04464
04465 public Q_SLOTS:
04529 inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
04530 {
04531 if (!invalidationReason().isEmpty()) {
04532 return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04533 invalidationReason(),
04534 invalidationMessage()
04535 ));
04536 }
04537
04538 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04539 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
04540 callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04541 return this->connection().asyncCall(callMessage, timeout);
04542 }
04543
04648 inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
04649 {
04650 if (!invalidationReason().isEmpty()) {
04651 return QDBusPendingReply<>(QDBusMessage::createError(
04652 invalidationReason(),
04653 invalidationMessage()
04654 ));
04655 }
04656
04657 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04658 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
04659 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
04660 return this->connection().asyncCall(callMessage, timeout);
04661 }
04662
04730 inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
04731 {
04732 if (!invalidationReason().isEmpty()) {
04733 return QDBusPendingReply<>(QDBusMessage::createError(
04734 invalidationReason(),
04735 invalidationMessage()
04736 ));
04737 }
04738
04739 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04740 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
04741 callMessage << QVariant::fromValue(contacts);
04742 return this->connection().asyncCall(callMessage, timeout);
04743 }
04744
04790 inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
04791 {
04792 if (!invalidationReason().isEmpty()) {
04793 return QDBusPendingReply<>(QDBusMessage::createError(
04794 invalidationReason(),
04795 invalidationMessage()
04796 ));
04797 }
04798
04799 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04800 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
04801 callMessage << QVariant::fromValue(contacts);
04802 return this->connection().asyncCall(callMessage, timeout);
04803 }
04804
04837 inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
04838 {
04839 if (!invalidationReason().isEmpty()) {
04840 return QDBusPendingReply<>(QDBusMessage::createError(
04841 invalidationReason(),
04842 invalidationMessage()
04843 ));
04844 }
04845
04846 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04847 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
04848 callMessage << QVariant::fromValue(contacts);
04849 return this->connection().asyncCall(callMessage, timeout);
04850 }
04851
04884 inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
04885 {
04886 if (!invalidationReason().isEmpty()) {
04887 return QDBusPendingReply<>(QDBusMessage::createError(
04888 invalidationReason(),
04889 invalidationMessage()
04890 ));
04891 }
04892
04893 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04894 this->staticInterfaceName(), QLatin1String("Unpublish"));
04895 callMessage << QVariant::fromValue(contacts);
04896 return this->connection().asyncCall(callMessage, timeout);
04897 }
04898
04899 Q_SIGNALS:
04909 void ContactListStateChanged(uint contactListState);
04910
04955 void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
04956
04977 void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
04978
04979 protected:
04980 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04981 };
04982
04990 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
04991 {
04992 Q_OBJECT
04993
04994 public:
05001 static inline QLatin1String staticInterfaceName()
05002 {
05003 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
05004 }
05005
05013 ConnectionInterfaceContactsInterface(
05014 const QString& busName,
05015 const QString& objectPath,
05016 QObject* parent = 0
05017 );
05018
05027 ConnectionInterfaceContactsInterface(
05028 const QDBusConnection& connection,
05029 const QString& busName,
05030 const QString& objectPath,
05031 QObject* parent = 0
05032 );
05033
05040 ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
05041
05049 explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
05050
05058 ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05059
05070 inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
05071 {
05072 return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
05073 }
05074
05081 Tp::PendingVariantMap *requestAllProperties() const
05082 {
05083 return internalRequestAllProperties();
05084 }
05085
05086 public Q_SLOTS:
05163 inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
05164 {
05165 if (!invalidationReason().isEmpty()) {
05166 return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
05167 invalidationReason(),
05168 invalidationMessage()
05169 ));
05170 }
05171
05172 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05173 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
05174 callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
05175 return this->connection().asyncCall(callMessage, timeout);
05176 }
05177
05178 protected:
05179 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05180 };
05181
05189 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
05190 {
05191 Q_OBJECT
05192
05193 public:
05200 static inline QLatin1String staticInterfaceName()
05201 {
05202 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
05203 }
05204
05212 ConnectionInterfaceLocationInterface(
05213 const QString& busName,
05214 const QString& objectPath,
05215 QObject* parent = 0
05216 );
05217
05226 ConnectionInterfaceLocationInterface(
05227 const QDBusConnection& connection,
05228 const QString& busName,
05229 const QString& objectPath,
05230 QObject* parent = 0
05231 );
05232
05239 ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
05240
05248 explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05249
05257 ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05258
05268 inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
05269 {
05270 return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
05271 }
05272
05285 inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
05286 {
05287 return internalRequestProperty(QLatin1String("LocationAccessControl"));
05288 }
05289
05302 inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
05303 {
05304 return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
05305 }
05306
05318 inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
05319 {
05320 return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
05321 }
05322
05329 Tp::PendingVariantMap *requestAllProperties() const
05330 {
05331 return internalRequestAllProperties();
05332 }
05333
05334 public Q_SLOTS:
05373 inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
05374 {
05375 if (!invalidationReason().isEmpty()) {
05376 return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
05377 invalidationReason(),
05378 invalidationMessage()
05379 ));
05380 }
05381
05382 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05383 this->staticInterfaceName(), QLatin1String("GetLocations"));
05384 callMessage << QVariant::fromValue(contacts);
05385 return this->connection().asyncCall(callMessage, timeout);
05386 }
05387
05412 inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
05413 {
05414 if (!invalidationReason().isEmpty()) {
05415 return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
05416 invalidationReason(),
05417 invalidationMessage()
05418 ));
05419 }
05420
05421 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05422 this->staticInterfaceName(), QLatin1String("RequestLocation"));
05423 callMessage << QVariant::fromValue(contact);
05424 return this->connection().asyncCall(callMessage, timeout);
05425 }
05426
05448 inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
05449 {
05450 if (!invalidationReason().isEmpty()) {
05451 return QDBusPendingReply<>(QDBusMessage::createError(
05452 invalidationReason(),
05453 invalidationMessage()
05454 ));
05455 }
05456
05457 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05458 this->staticInterfaceName(), QLatin1String("SetLocation"));
05459 callMessage << QVariant::fromValue(location);
05460 return this->connection().asyncCall(callMessage, timeout);
05461 }
05462
05463 Q_SIGNALS:
05478 void LocationUpdated(uint contact, const QVariantMap& location);
05479
05480 protected:
05481 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05482 };
05483
05491 class TELEPATHY_QT4_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
05492 {
05493 Q_OBJECT
05494
05495 public:
05502 static inline QLatin1String staticInterfaceName()
05503 {
05504 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
05505 }
05506
05514 ConnectionInterfaceMailNotificationInterface(
05515 const QString& busName,
05516 const QString& objectPath,
05517 QObject* parent = 0
05518 );
05519
05528 ConnectionInterfaceMailNotificationInterface(
05529 const QDBusConnection& connection,
05530 const QString& busName,
05531 const QString& objectPath,
05532 QObject* parent = 0
05533 );
05534
05541 ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
05542
05550 explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05551
05559 ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05560
05575 inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
05576 {
05577 return internalRequestProperty(QLatin1String("MailNotificationFlags"));
05578 }
05579
05602 inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
05603 {
05604 return internalRequestProperty(QLatin1String("UnreadMailCount"));
05605 }
05606
05623 inline Tp::PendingVariant *requestPropertyUnreadMails() const
05624 {
05625 return internalRequestProperty(QLatin1String("UnreadMails"));
05626 }
05627
05642 inline Tp::PendingVariant *requestPropertyMailAddress() const
05643 {
05644 return internalRequestProperty(QLatin1String("MailAddress"));
05645 }
05646
05653 Tp::PendingVariantMap *requestAllProperties() const
05654 {
05655 return internalRequestAllProperties();
05656 }
05657
05658 public Q_SLOTS:
05682 inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
05683 {
05684 if (!invalidationReason().isEmpty()) {
05685 return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05686 invalidationReason(),
05687 invalidationMessage()
05688 ));
05689 }
05690
05691 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05692 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
05693 return this->connection().asyncCall(callMessage, timeout);
05694 }
05695
05725 inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
05726 {
05727 if (!invalidationReason().isEmpty()) {
05728 return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05729 invalidationReason(),
05730 invalidationMessage()
05731 ));
05732 }
05733
05734 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05735 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
05736 callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
05737 return this->connection().asyncCall(callMessage, timeout);
05738 }
05739
05740 Q_SIGNALS:
05761 void MailsReceived(const Tp::MailList& mails);
05762
05800 void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
05801
05802 protected:
05803 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05804 };
05805
05813 class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
05814 {
05815 Q_OBJECT
05816
05817 public:
05824 static inline QLatin1String staticInterfaceName()
05825 {
05826 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
05827 }
05828
05836 ConnectionInterfacePowerSavingInterface(
05837 const QString& busName,
05838 const QString& objectPath,
05839 QObject* parent = 0
05840 );
05841
05850 ConnectionInterfacePowerSavingInterface(
05851 const QDBusConnection& connection,
05852 const QString& busName,
05853 const QString& objectPath,
05854 QObject* parent = 0
05855 );
05856
05863 ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
05864
05872 explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
05873
05881 ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05882
05896 inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
05897 {
05898 return internalRequestProperty(QLatin1String("PowerSavingActive"));
05899 }
05900
05907 Tp::PendingVariantMap *requestAllProperties() const
05908 {
05909 return internalRequestAllProperties();
05910 }
05911
05912 public Q_SLOTS:
05944 inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
05945 {
05946 if (!invalidationReason().isEmpty()) {
05947 return QDBusPendingReply<>(QDBusMessage::createError(
05948 invalidationReason(),
05949 invalidationMessage()
05950 ));
05951 }
05952
05953 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05954 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
05955 callMessage << QVariant::fromValue(activate);
05956 return this->connection().asyncCall(callMessage, timeout);
05957 }
05958
05959 Q_SIGNALS:
05970 void PowerSavingChanged(bool active);
05971
05972 protected:
05973 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05974 };
05975
05983 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
05984 {
05985 Q_OBJECT
05986
05987 public:
05994 static inline QLatin1String staticInterfaceName()
05995 {
05996 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
05997 }
05998
06006 ConnectionInterfacePresenceInterface(
06007 const QString& busName,
06008 const QString& objectPath,
06009 QObject* parent = 0
06010 );
06011
06020 ConnectionInterfacePresenceInterface(
06021 const QDBusConnection& connection,
06022 const QString& busName,
06023 const QString& objectPath,
06024 QObject* parent = 0
06025 );
06026
06033 ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
06034
06042 explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06043
06051 ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06052
06059 Tp::PendingVariantMap *requestAllProperties() const
06060 {
06061 return internalRequestAllProperties();
06062 }
06063
06064 public Q_SLOTS:
06086 inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
06087 {
06088 if (!invalidationReason().isEmpty()) {
06089 return QDBusPendingReply<>(QDBusMessage::createError(
06090 invalidationReason(),
06091 invalidationMessage()
06092 ));
06093 }
06094
06095 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06096 this->staticInterfaceName(), QLatin1String("AddStatus"));
06097 callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
06098 return this->connection().asyncCall(callMessage, timeout);
06099 }
06100
06114 inline QDBusPendingReply<> ClearStatus(int timeout = -1)
06115 {
06116 if (!invalidationReason().isEmpty()) {
06117 return QDBusPendingReply<>(QDBusMessage::createError(
06118 invalidationReason(),
06119 invalidationMessage()
06120 ));
06121 }
06122
06123 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06124 this->staticInterfaceName(), QLatin1String("ClearStatus"));
06125 return this->connection().asyncCall(callMessage, timeout);
06126 }
06127
06151 inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
06152 {
06153 if (!invalidationReason().isEmpty()) {
06154 return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
06155 invalidationReason(),
06156 invalidationMessage()
06157 ));
06158 }
06159
06160 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06161 this->staticInterfaceName(), QLatin1String("GetPresence"));
06162 callMessage << QVariant::fromValue(contacts);
06163 return this->connection().asyncCall(callMessage, timeout);
06164 }
06165
06187 inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
06188 {
06189 if (!invalidationReason().isEmpty()) {
06190 return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
06191 invalidationReason(),
06192 invalidationMessage()
06193 ));
06194 }
06195
06196 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06197 this->staticInterfaceName(), QLatin1String("GetStatuses"));
06198 return this->connection().asyncCall(callMessage, timeout);
06199 }
06200
06219 inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
06220 {
06221 if (!invalidationReason().isEmpty()) {
06222 return QDBusPendingReply<>(QDBusMessage::createError(
06223 invalidationReason(),
06224 invalidationMessage()
06225 ));
06226 }
06227
06228 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06229 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
06230 callMessage << QVariant::fromValue(status);
06231 return this->connection().asyncCall(callMessage, timeout);
06232 }
06233
06252 inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
06253 {
06254 if (!invalidationReason().isEmpty()) {
06255 return QDBusPendingReply<>(QDBusMessage::createError(
06256 invalidationReason(),
06257 invalidationMessage()
06258 ));
06259 }
06260
06261 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06262 this->staticInterfaceName(), QLatin1String("RequestPresence"));
06263 callMessage << QVariant::fromValue(contacts);
06264 return this->connection().asyncCall(callMessage, timeout);
06265 }
06266
06282 inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
06283 {
06284 if (!invalidationReason().isEmpty()) {
06285 return QDBusPendingReply<>(QDBusMessage::createError(
06286 invalidationReason(),
06287 invalidationMessage()
06288 ));
06289 }
06290
06291 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06292 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
06293 callMessage << QVariant::fromValue(time);
06294 return this->connection().asyncCall(callMessage, timeout);
06295 }
06296
06332 inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
06333 {
06334 if (!invalidationReason().isEmpty()) {
06335 return QDBusPendingReply<>(QDBusMessage::createError(
06336 invalidationReason(),
06337 invalidationMessage()
06338 ));
06339 }
06340
06341 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06342 this->staticInterfaceName(), QLatin1String("SetStatus"));
06343 callMessage << QVariant::fromValue(statuses);
06344 return this->connection().asyncCall(callMessage, timeout);
06345 }
06346
06347 Q_SIGNALS:
06364 void PresenceUpdate(const Tp::ContactPresences& presence);
06365
06366 protected:
06367 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06368 };
06369
06377 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
06378 {
06379 Q_OBJECT
06380
06381 public:
06388 static inline QLatin1String staticInterfaceName()
06389 {
06390 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
06391 }
06392
06400 ConnectionInterfaceRequestsInterface(
06401 const QString& busName,
06402 const QString& objectPath,
06403 QObject* parent = 0
06404 );
06405
06414 ConnectionInterfaceRequestsInterface(
06415 const QDBusConnection& connection,
06416 const QString& busName,
06417 const QString& objectPath,
06418 QObject* parent = 0
06419 );
06420
06427 ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
06428
06436 explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
06437
06445 ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06446
06457 inline Tp::PendingVariant *requestPropertyChannels() const
06458 {
06459 return internalRequestProperty(QLatin1String("Channels"));
06460 }
06461
06489 inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
06490 {
06491 return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
06492 }
06493
06500 Tp::PendingVariantMap *requestAllProperties() const
06501 {
06502 return internalRequestAllProperties();
06503 }
06504
06505 public Q_SLOTS:
06579 inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
06580 {
06581 if (!invalidationReason().isEmpty()) {
06582 return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06583 invalidationReason(),
06584 invalidationMessage()
06585 ));
06586 }
06587
06588 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06589 this->staticInterfaceName(), QLatin1String("CreateChannel"));
06590 callMessage << QVariant::fromValue(request);
06591 return this->connection().asyncCall(callMessage, timeout);
06592 }
06593
06650 inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
06651 {
06652 if (!invalidationReason().isEmpty()) {
06653 return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06654 invalidationReason(),
06655 invalidationMessage()
06656 ));
06657 }
06658
06659 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06660 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
06661 callMessage << QVariant::fromValue(request);
06662 return this->connection().asyncCall(callMessage, timeout);
06663 }
06664
06665 Q_SIGNALS:
06707 void NewChannels(const Tp::ChannelDetailsList& channels);
06708
06721 void ChannelClosed(const QDBusObjectPath& removed);
06722
06723 protected:
06724 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06725 };
06726
06734 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
06735 {
06736 Q_OBJECT
06737
06738 public:
06745 static inline QLatin1String staticInterfaceName()
06746 {
06747 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
06748 }
06749
06757 ConnectionInterfaceServicePointInterface(
06758 const QString& busName,
06759 const QString& objectPath,
06760 QObject* parent = 0
06761 );
06762
06771 ConnectionInterfaceServicePointInterface(
06772 const QDBusConnection& connection,
06773 const QString& busName,
06774 const QString& objectPath,
06775 QObject* parent = 0
06776 );
06777
06784 ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
06785
06793 explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
06794
06802 ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06803
06813 inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
06814 {
06815 return internalRequestProperty(QLatin1String("KnownServicePoints"));
06816 }
06817
06824 Tp::PendingVariantMap *requestAllProperties() const
06825 {
06826 return internalRequestAllProperties();
06827 }
06828
06829 Q_SIGNALS:
06841 void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
06842
06843 protected:
06844 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06845 };
06846
06854 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
06855 {
06856 Q_OBJECT
06857
06858 public:
06865 static inline QLatin1String staticInterfaceName()
06866 {
06867 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
06868 }
06869
06877 ConnectionInterfaceSimplePresenceInterface(
06878 const QString& busName,
06879 const QString& objectPath,
06880 QObject* parent = 0
06881 );
06882
06891 ConnectionInterfaceSimplePresenceInterface(
06892 const QDBusConnection& connection,
06893 const QString& busName,
06894 const QString& objectPath,
06895 QObject* parent = 0
06896 );
06897
06904 ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
06905
06913 explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06914
06922 ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06923
06963 inline Tp::PendingVariant *requestPropertyStatuses() const
06964 {
06965 return internalRequestProperty(QLatin1String("Statuses"));
06966 }
06967
06974 Tp::PendingVariantMap *requestAllProperties() const
06975 {
06976 return internalRequestAllProperties();
06977 }
06978
06979 public Q_SLOTS:
07039 inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
07040 {
07041 if (!invalidationReason().isEmpty()) {
07042 return QDBusPendingReply<>(QDBusMessage::createError(
07043 invalidationReason(),
07044 invalidationMessage()
07045 ));
07046 }
07047
07048 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07049 this->staticInterfaceName(), QLatin1String("SetPresence"));
07050 callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
07051 return this->connection().asyncCall(callMessage, timeout);
07052 }
07053
07083 inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
07084 {
07085 if (!invalidationReason().isEmpty()) {
07086 return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
07087 invalidationReason(),
07088 invalidationMessage()
07089 ));
07090 }
07091
07092 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07093 this->staticInterfaceName(), QLatin1String("GetPresences"));
07094 callMessage << QVariant::fromValue(contacts);
07095 return this->connection().asyncCall(callMessage, timeout);
07096 }
07097
07098 Q_SIGNALS:
07111 void PresencesChanged(const Tp::SimpleContactPresences& presence);
07112
07113 protected:
07114 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07115 };
07116 }
07117 }
07118 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
07119 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
07120 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
07121 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
07122 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
07123 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
07124 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
07125 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
07126 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
07127 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
07128 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
07129 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
07130 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
07131 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
07132 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
07133 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
07134 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
07135 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
07136 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
07137 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
07138 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)