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
00168 inline Tp::PendingVariant *requestPropertyStatus() const
00169 {
00170 return internalRequestProperty(QLatin1String("Status"));
00171 }
00172
00187 inline Tp::PendingVariant *requestPropertyHasImmortalHandles() const
00188 {
00189 return internalRequestProperty(QLatin1String("HasImmortalHandles"));
00190 }
00191
00198 Tp::PendingVariantMap *requestAllProperties() const
00199 {
00200 return internalRequestAllProperties();
00201 }
00202
00203 public Q_SLOTS:
00221 inline QDBusPendingReply<> Connect(int timeout = -1)
00222 {
00223 if (!invalidationReason().isEmpty()) {
00224 return QDBusPendingReply<>(QDBusMessage::createError(
00225 invalidationReason(),
00226 invalidationMessage()
00227 ));
00228 }
00229
00230 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00231 this->staticInterfaceName(), QLatin1String("Connect"));
00232 return this->connection().asyncCall(callMessage, timeout);
00233 }
00234
00247 inline QDBusPendingReply<> Disconnect(int timeout = -1)
00248 {
00249 if (!invalidationReason().isEmpty()) {
00250 return QDBusPendingReply<>(QDBusMessage::createError(
00251 invalidationReason(),
00252 invalidationMessage()
00253 ));
00254 }
00255
00256 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00257 this->staticInterfaceName(), QLatin1String("Disconnect"));
00258 return this->connection().asyncCall(callMessage, timeout);
00259 }
00260
00279 inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00280 {
00281 if (!invalidationReason().isEmpty()) {
00282 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00283 invalidationReason(),
00284 invalidationMessage()
00285 ));
00286 }
00287
00288 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00289 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00290 return this->connection().asyncCall(callMessage, timeout);
00291 }
00292
00307 inline QDBusPendingReply<QString> GetProtocol(int timeout = -1)
00308 {
00309 if (!invalidationReason().isEmpty()) {
00310 return QDBusPendingReply<QString>(QDBusMessage::createError(
00311 invalidationReason(),
00312 invalidationMessage()
00313 ));
00314 }
00315
00316 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00317 this->staticInterfaceName(), QLatin1String("GetProtocol"));
00318 return this->connection().asyncCall(callMessage, timeout);
00319 }
00320
00336 inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
00337 {
00338 if (!invalidationReason().isEmpty()) {
00339 return QDBusPendingReply<uint>(QDBusMessage::createError(
00340 invalidationReason(),
00341 invalidationMessage()
00342 ));
00343 }
00344
00345 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00346 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
00347 return this->connection().asyncCall(callMessage, timeout);
00348 }
00349
00364 inline QDBusPendingReply<uint> GetStatus(int timeout = -1)
00365 {
00366 if (!invalidationReason().isEmpty()) {
00367 return QDBusPendingReply<uint>(QDBusMessage::createError(
00368 invalidationReason(),
00369 invalidationMessage()
00370 ));
00371 }
00372
00373 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00374 this->staticInterfaceName(), QLatin1String("GetStatus"));
00375 return this->connection().asyncCall(callMessage, timeout);
00376 }
00377
00420 inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00421 {
00422 if (!invalidationReason().isEmpty()) {
00423 return QDBusPendingReply<>(QDBusMessage::createError(
00424 invalidationReason(),
00425 invalidationMessage()
00426 ));
00427 }
00428
00429 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00430 this->staticInterfaceName(), QLatin1String("HoldHandles"));
00431 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00432 return this->connection().asyncCall(callMessage, timeout);
00433 }
00434
00458 inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00459 {
00460 if (!invalidationReason().isEmpty()) {
00461 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00462 invalidationReason(),
00463 invalidationMessage()
00464 ));
00465 }
00466
00467 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00468 this->staticInterfaceName(), QLatin1String("InspectHandles"));
00469 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00470 return this->connection().asyncCall(callMessage, timeout);
00471 }
00472
00487 inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels(int timeout = -1)
00488 {
00489 if (!invalidationReason().isEmpty()) {
00490 return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00491 invalidationReason(),
00492 invalidationMessage()
00493 ));
00494 }
00495
00496 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00497 this->staticInterfaceName(), QLatin1String("ListChannels"));
00498 return this->connection().asyncCall(callMessage, timeout);
00499 }
00500
00526 inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00527 {
00528 if (!invalidationReason().isEmpty()) {
00529 return QDBusPendingReply<>(QDBusMessage::createError(
00530 invalidationReason(),
00531 invalidationMessage()
00532 ));
00533 }
00534
00535 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00536 this->staticInterfaceName(), QLatin1String("ReleaseHandles"));
00537 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00538 return this->connection().asyncCall(callMessage, timeout);
00539 }
00540
00620 inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler, int timeout = -1)
00621 {
00622 if (!invalidationReason().isEmpty()) {
00623 return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00624 invalidationReason(),
00625 invalidationMessage()
00626 ));
00627 }
00628
00629 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00630 this->staticInterfaceName(), QLatin1String("RequestChannel"));
00631 callMessage << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00632 return this->connection().asyncCall(callMessage, timeout);
00633 }
00634
00675 inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers, int timeout = -1)
00676 {
00677 if (!invalidationReason().isEmpty()) {
00678 return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00679 invalidationReason(),
00680 invalidationMessage()
00681 ));
00682 }
00683
00684 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00685 this->staticInterfaceName(), QLatin1String("RequestHandles"));
00686 callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
00687 return this->connection().asyncCall(callMessage, timeout);
00688 }
00689
00783 inline QDBusPendingReply<> AddClientInterest(const QStringList& tokens, int timeout = -1)
00784 {
00785 if (!invalidationReason().isEmpty()) {
00786 return QDBusPendingReply<>(QDBusMessage::createError(
00787 invalidationReason(),
00788 invalidationMessage()
00789 ));
00790 }
00791
00792 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00793 this->staticInterfaceName(), QLatin1String("AddClientInterest"));
00794 callMessage << QVariant::fromValue(tokens);
00795 return this->connection().asyncCall(callMessage, timeout);
00796 }
00797
00829 inline QDBusPendingReply<> RemoveClientInterest(const QStringList& tokens, int timeout = -1)
00830 {
00831 if (!invalidationReason().isEmpty()) {
00832 return QDBusPendingReply<>(QDBusMessage::createError(
00833 invalidationReason(),
00834 invalidationMessage()
00835 ));
00836 }
00837
00838 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00839 this->staticInterfaceName(), QLatin1String("RemoveClientInterest"));
00840 callMessage << QVariant::fromValue(tokens);
00841 return this->connection().asyncCall(callMessage, timeout);
00842 }
00843
00844 Q_SIGNALS:
00856 void SelfHandleChanged(uint selfHandle);
00857
00901 void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00902
00972 void ConnectionError(const QString& error, const QVariantMap& details);
00973
00990 void StatusChanged(uint status, uint reason);
00991
00992 protected:
00993 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00994 };
00995
01003 class TP_QT_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
01004 {
01005 Q_OBJECT
01006
01007 public:
01014 static inline QLatin1String staticInterfaceName()
01015 {
01016 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
01017 }
01018
01026 ConnectionInterfaceAliasingInterface(
01027 const QString& busName,
01028 const QString& objectPath,
01029 QObject* parent = 0
01030 );
01031
01040 ConnectionInterfaceAliasingInterface(
01041 const QDBusConnection& connection,
01042 const QString& busName,
01043 const QString& objectPath,
01044 QObject* parent = 0
01045 );
01046
01053 ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
01054
01062 explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
01063
01071 ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01072
01079 Tp::PendingVariantMap *requestAllProperties() const
01080 {
01081 return internalRequestAllProperties();
01082 }
01083
01084 public Q_SLOTS:
01100 inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
01101 {
01102 if (!invalidationReason().isEmpty()) {
01103 return QDBusPendingReply<uint>(QDBusMessage::createError(
01104 invalidationReason(),
01105 invalidationMessage()
01106 ));
01107 }
01108
01109 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01110 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
01111 return this->connection().asyncCall(callMessage, timeout);
01112 }
01113
01132 inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
01133 {
01134 if (!invalidationReason().isEmpty()) {
01135 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01136 invalidationReason(),
01137 invalidationMessage()
01138 ));
01139 }
01140
01141 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01142 this->staticInterfaceName(), QLatin1String("RequestAliases"));
01143 callMessage << QVariant::fromValue(contacts);
01144 return this->connection().asyncCall(callMessage, timeout);
01145 }
01146
01169 inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
01170 {
01171 if (!invalidationReason().isEmpty()) {
01172 return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
01173 invalidationReason(),
01174 invalidationMessage()
01175 ));
01176 }
01177
01178 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01179 this->staticInterfaceName(), QLatin1String("GetAliases"));
01180 callMessage << QVariant::fromValue(contacts);
01181 return this->connection().asyncCall(callMessage, timeout);
01182 }
01183
01203 inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
01204 {
01205 if (!invalidationReason().isEmpty()) {
01206 return QDBusPendingReply<>(QDBusMessage::createError(
01207 invalidationReason(),
01208 invalidationMessage()
01209 ));
01210 }
01211
01212 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01213 this->staticInterfaceName(), QLatin1String("SetAliases"));
01214 callMessage << QVariant::fromValue(aliases);
01215 return this->connection().asyncCall(callMessage, timeout);
01216 }
01217
01218 Q_SIGNALS:
01235 void AliasesChanged(const Tp::AliasPairList& aliases);
01236
01237 protected:
01238 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01239 };
01240
01248 class TP_QT_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
01249 {
01250 Q_OBJECT
01251
01252 public:
01259 static inline QLatin1String staticInterfaceName()
01260 {
01261 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
01262 }
01263
01271 ConnectionInterfaceAnonymityInterface(
01272 const QString& busName,
01273 const QString& objectPath,
01274 QObject* parent = 0
01275 );
01276
01285 ConnectionInterfaceAnonymityInterface(
01286 const QDBusConnection& connection,
01287 const QString& busName,
01288 const QString& objectPath,
01289 QObject* parent = 0
01290 );
01291
01298 ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
01299
01307 explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01308
01316 ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01317
01328 inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
01329 {
01330 return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
01331 }
01332
01348 inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
01349 {
01350 return internalRequestProperty(QLatin1String("AnonymityMandatory"));
01351 }
01352
01368 inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
01369 {
01370 return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
01371 }
01372
01385 inline Tp::PendingVariant *requestPropertyAnonymityModes() const
01386 {
01387 return internalRequestProperty(QLatin1String("AnonymityModes"));
01388 }
01389
01402 inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
01403 {
01404 return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
01405 }
01406
01413 Tp::PendingVariantMap *requestAllProperties() const
01414 {
01415 return internalRequestAllProperties();
01416 }
01417
01418 Q_SIGNALS:
01428 void AnonymityModesChanged(uint modes);
01429
01430 protected:
01431 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01432 };
01433
01441 class TP_QT_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01442 {
01443 Q_OBJECT
01444
01445 public:
01452 static inline QLatin1String staticInterfaceName()
01453 {
01454 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
01455 }
01456
01464 ConnectionInterfaceAvatarsInterface(
01465 const QString& busName,
01466 const QString& objectPath,
01467 QObject* parent = 0
01468 );
01469
01478 ConnectionInterfaceAvatarsInterface(
01479 const QDBusConnection& connection,
01480 const QString& busName,
01481 const QString& objectPath,
01482 QObject* parent = 0
01483 );
01484
01491 ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01492
01500 explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01501
01509 ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01510
01522 inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
01523 {
01524 return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
01525 }
01526
01538 inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
01539 {
01540 return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
01541 }
01542
01554 inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
01555 {
01556 return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
01557 }
01558
01573 inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
01574 {
01575 return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
01576 }
01577
01590 inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
01591 {
01592 return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
01593 }
01594
01606 inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
01607 {
01608 return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
01609 }
01610
01622 inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
01623 {
01624 return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
01625 }
01626
01638 inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
01639 {
01640 return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
01641 }
01642
01649 Tp::PendingVariantMap *requestAllProperties() const
01650 {
01651 return internalRequestAllProperties();
01652 }
01653
01654 public Q_SLOTS:
01689 inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
01690 {
01691 if (!invalidationReason().isEmpty()) {
01692 return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01693 invalidationReason(),
01694 invalidationMessage()
01695 ));
01696 }
01697
01698 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01699 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
01700 return this->connection().asyncCall(callMessage, timeout);
01701 }
01702
01724 inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01725 {
01726 if (!invalidationReason().isEmpty()) {
01727 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01728 invalidationReason(),
01729 invalidationMessage()
01730 ));
01731 }
01732
01733 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01734 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
01735 callMessage << QVariant::fromValue(contacts);
01736 return this->connection().asyncCall(callMessage, timeout);
01737 }
01738
01766 inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01767 {
01768 if (!invalidationReason().isEmpty()) {
01769 return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01770 invalidationReason(),
01771 invalidationMessage()
01772 ));
01773 }
01774
01775 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01776 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
01777 callMessage << QVariant::fromValue(contacts);
01778 return this->connection().asyncCall(callMessage, timeout);
01779 }
01780
01805 inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
01806 {
01807 if (!invalidationReason().isEmpty()) {
01808 return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01809 invalidationReason(),
01810 invalidationMessage()
01811 ));
01812 }
01813
01814 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01815 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
01816 callMessage << QVariant::fromValue(contact);
01817 return this->connection().asyncCall(callMessage, timeout);
01818 }
01819
01838 inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
01839 {
01840 if (!invalidationReason().isEmpty()) {
01841 return QDBusPendingReply<>(QDBusMessage::createError(
01842 invalidationReason(),
01843 invalidationMessage()
01844 ));
01845 }
01846
01847 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01848 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
01849 callMessage << QVariant::fromValue(contacts);
01850 return this->connection().asyncCall(callMessage, timeout);
01851 }
01852
01876 inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
01877 {
01878 if (!invalidationReason().isEmpty()) {
01879 return QDBusPendingReply<QString>(QDBusMessage::createError(
01880 invalidationReason(),
01881 invalidationMessage()
01882 ));
01883 }
01884
01885 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01886 this->staticInterfaceName(), QLatin1String("SetAvatar"));
01887 callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01888 return this->connection().asyncCall(callMessage, timeout);
01889 }
01890
01901 inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
01902 {
01903 if (!invalidationReason().isEmpty()) {
01904 return QDBusPendingReply<>(QDBusMessage::createError(
01905 invalidationReason(),
01906 invalidationMessage()
01907 ));
01908 }
01909
01910 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01911 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
01912 return this->connection().asyncCall(callMessage, timeout);
01913 }
01914
01915 Q_SIGNALS:
01932 void AvatarUpdated(uint contact, const QString& newAvatarToken);
01933
01956 void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01957
01958 protected:
01959 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01960 };
01961
01969 class TP_QT_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01970 {
01971 Q_OBJECT
01972
01973 public:
01980 static inline QLatin1String staticInterfaceName()
01981 {
01982 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
01983 }
01984
01992 ConnectionInterfaceBalanceInterface(
01993 const QString& busName,
01994 const QString& objectPath,
01995 QObject* parent = 0
01996 );
01997
02006 ConnectionInterfaceBalanceInterface(
02007 const QDBusConnection& connection,
02008 const QString& busName,
02009 const QString& objectPath,
02010 QObject* parent = 0
02011 );
02012
02019 ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
02020
02028 explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
02029
02037 ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02038
02057 inline Tp::PendingVariant *requestPropertyAccountBalance() const
02058 {
02059 return internalRequestProperty(QLatin1String("AccountBalance"));
02060 }
02061
02079 inline Tp::PendingVariant *requestPropertyManageCreditURI() const
02080 {
02081 return internalRequestProperty(QLatin1String("ManageCreditURI"));
02082 }
02083
02090 Tp::PendingVariantMap *requestAllProperties() const
02091 {
02092 return internalRequestAllProperties();
02093 }
02094
02095 Q_SIGNALS:
02110 void BalanceChanged(const Tp::CurrencyAmount& balance);
02111
02112 protected:
02113 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02114 };
02115
02123 class TP_QT_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
02124 {
02125 Q_OBJECT
02126
02127 public:
02134 static inline QLatin1String staticInterfaceName()
02135 {
02136 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
02137 }
02138
02146 ConnectionInterfaceCapabilitiesInterface(
02147 const QString& busName,
02148 const QString& objectPath,
02149 QObject* parent = 0
02150 );
02151
02160 ConnectionInterfaceCapabilitiesInterface(
02161 const QDBusConnection& connection,
02162 const QString& busName,
02163 const QString& objectPath,
02164 QObject* parent = 0
02165 );
02166
02173 ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
02174
02182 explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02183
02191 ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02192
02199 Tp::PendingVariantMap *requestAllProperties() const
02200 {
02201 return internalRequestAllProperties();
02202 }
02203
02204 public Q_SLOTS:
02258 inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
02259 {
02260 if (!invalidationReason().isEmpty()) {
02261 return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
02262 invalidationReason(),
02263 invalidationMessage()
02264 ));
02265 }
02266
02267 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02268 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
02269 callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
02270 return this->connection().asyncCall(callMessage, timeout);
02271 }
02272
02307 inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
02308 {
02309 if (!invalidationReason().isEmpty()) {
02310 return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
02311 invalidationReason(),
02312 invalidationMessage()
02313 ));
02314 }
02315
02316 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02317 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
02318 callMessage << QVariant::fromValue(handles);
02319 return this->connection().asyncCall(callMessage, timeout);
02320 }
02321
02322 Q_SIGNALS:
02349 void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
02350
02351 protected:
02352 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02353 };
02354
02362 class TP_QT_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
02363 {
02364 Q_OBJECT
02365
02366 public:
02373 static inline QLatin1String staticInterfaceName()
02374 {
02375 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
02376 }
02377
02385 ConnectionInterfaceCellularInterface(
02386 const QString& busName,
02387 const QString& objectPath,
02388 QObject* parent = 0
02389 );
02390
02399 ConnectionInterfaceCellularInterface(
02400 const QDBusConnection& connection,
02401 const QString& busName,
02402 const QString& objectPath,
02403 QObject* parent = 0
02404 );
02405
02412 ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02413
02421 explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02422
02430 ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02431
02450 inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
02451 {
02452 return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
02453 }
02454
02473 inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
02474 {
02475 return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
02476 }
02477
02500 inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
02501 {
02502 return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
02503 }
02504
02527 inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
02528 {
02529 return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
02530 }
02531
02548 inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
02549 {
02550 return internalRequestProperty(QLatin1String("MessageServiceCentre"));
02551 }
02552
02569 inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
02570 {
02571 return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
02572 }
02573
02587 inline Tp::PendingVariant *requestPropertyIMSI() const
02588 {
02589 return internalRequestProperty(QLatin1String("IMSI"));
02590 }
02591
02610 inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
02611 {
02612 return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
02613 }
02614
02633 inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
02634 {
02635 return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
02636 }
02637
02663 inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
02664 {
02665 return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
02666 }
02667
02693 inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
02694 {
02695 return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
02696 }
02697
02704 Tp::PendingVariantMap *requestAllProperties() const
02705 {
02706 return internalRequestAllProperties();
02707 }
02708
02709 Q_SIGNALS:
02725 void IMSIChanged(const QString& IMSI);
02726
02727 protected:
02728 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02729 };
02730
02738 class TP_QT_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
02739 {
02740 Q_OBJECT
02741
02742 public:
02749 static inline QLatin1String staticInterfaceName()
02750 {
02751 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
02752 }
02753
02761 ConnectionInterfaceClientTypesInterface(
02762 const QString& busName,
02763 const QString& objectPath,
02764 QObject* parent = 0
02765 );
02766
02775 ConnectionInterfaceClientTypesInterface(
02776 const QDBusConnection& connection,
02777 const QString& busName,
02778 const QString& objectPath,
02779 QObject* parent = 0
02780 );
02781
02788 ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
02789
02797 explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02798
02806 ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02807
02814 Tp::PendingVariantMap *requestAllProperties() const
02815 {
02816 return internalRequestAllProperties();
02817 }
02818
02819 public Q_SLOTS:
02848 inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
02849 {
02850 if (!invalidationReason().isEmpty()) {
02851 return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
02852 invalidationReason(),
02853 invalidationMessage()
02854 ));
02855 }
02856
02857 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02858 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
02859 callMessage << QVariant::fromValue(contacts);
02860 return this->connection().asyncCall(callMessage, timeout);
02861 }
02862
02887 inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
02888 {
02889 if (!invalidationReason().isEmpty()) {
02890 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02891 invalidationReason(),
02892 invalidationMessage()
02893 ));
02894 }
02895
02896 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02897 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
02898 callMessage << QVariant::fromValue(contact);
02899 return this->connection().asyncCall(callMessage, timeout);
02900 }
02901
02902 Q_SIGNALS:
02917 void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
02918
02919 protected:
02920 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02921 };
02922
02930 class TP_QT_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
02931 {
02932 Q_OBJECT
02933
02934 public:
02941 static inline QLatin1String staticInterfaceName()
02942 {
02943 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
02944 }
02945
02953 ConnectionInterfaceContactBlockingInterface(
02954 const QString& busName,
02955 const QString& objectPath,
02956 QObject* parent = 0
02957 );
02958
02967 ConnectionInterfaceContactBlockingInterface(
02968 const QDBusConnection& connection,
02969 const QString& busName,
02970 const QString& objectPath,
02971 QObject* parent = 0
02972 );
02973
02980 ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
02981
02989 explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
02990
02998 ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02999
03016 inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
03017 {
03018 return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
03019 }
03020
03027 Tp::PendingVariantMap *requestAllProperties() const
03028 {
03029 return internalRequestAllProperties();
03030 }
03031
03032 public Q_SLOTS:
03092 inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
03093 {
03094 if (!invalidationReason().isEmpty()) {
03095 return QDBusPendingReply<>(QDBusMessage::createError(
03096 invalidationReason(),
03097 invalidationMessage()
03098 ));
03099 }
03100
03101 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03102 this->staticInterfaceName(), QLatin1String("BlockContacts"));
03103 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
03104 return this->connection().asyncCall(callMessage, timeout);
03105 }
03106
03125 inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
03126 {
03127 if (!invalidationReason().isEmpty()) {
03128 return QDBusPendingReply<>(QDBusMessage::createError(
03129 invalidationReason(),
03130 invalidationMessage()
03131 ));
03132 }
03133
03134 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03135 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
03136 callMessage << QVariant::fromValue(contacts);
03137 return this->connection().asyncCall(callMessage, timeout);
03138 }
03139
03160 inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
03161 {
03162 if (!invalidationReason().isEmpty()) {
03163 return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
03164 invalidationReason(),
03165 invalidationMessage()
03166 ));
03167 }
03168
03169 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03170 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
03171 return this->connection().asyncCall(callMessage, timeout);
03172 }
03173
03174 Q_SIGNALS:
03193 void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
03194
03195 protected:
03196 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03197 };
03198
03206 class TP_QT_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
03207 {
03208 Q_OBJECT
03209
03210 public:
03217 static inline QLatin1String staticInterfaceName()
03218 {
03219 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
03220 }
03221
03229 ConnectionInterfaceContactCapabilitiesInterface(
03230 const QString& busName,
03231 const QString& objectPath,
03232 QObject* parent = 0
03233 );
03234
03243 ConnectionInterfaceContactCapabilitiesInterface(
03244 const QDBusConnection& connection,
03245 const QString& busName,
03246 const QString& objectPath,
03247 QObject* parent = 0
03248 );
03249
03256 ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
03257
03265 explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
03266
03274 ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03275
03282 Tp::PendingVariantMap *requestAllProperties() const
03283 {
03284 return internalRequestAllProperties();
03285 }
03286
03287 public Q_SLOTS:
03350 inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
03351 {
03352 if (!invalidationReason().isEmpty()) {
03353 return QDBusPendingReply<>(QDBusMessage::createError(
03354 invalidationReason(),
03355 invalidationMessage()
03356 ));
03357 }
03358
03359 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03360 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
03361 callMessage << QVariant::fromValue(handlerCapabilities);
03362 return this->connection().asyncCall(callMessage, timeout);
03363 }
03364
03400 inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
03401 {
03402 if (!invalidationReason().isEmpty()) {
03403 return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
03404 invalidationReason(),
03405 invalidationMessage()
03406 ));
03407 }
03408
03409 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03410 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
03411 callMessage << QVariant::fromValue(handles);
03412 return this->connection().asyncCall(callMessage, timeout);
03413 }
03414
03415 Q_SIGNALS:
03436 void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
03437
03438 protected:
03439 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03440 };
03441
03449 class TP_QT_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
03450 {
03451 Q_OBJECT
03452
03453 public:
03460 static inline QLatin1String staticInterfaceName()
03461 {
03462 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
03463 }
03464
03472 ConnectionInterfaceContactGroupsInterface(
03473 const QString& busName,
03474 const QString& objectPath,
03475 QObject* parent = 0
03476 );
03477
03486 ConnectionInterfaceContactGroupsInterface(
03487 const QDBusConnection& connection,
03488 const QString& busName,
03489 const QString& objectPath,
03490 QObject* parent = 0
03491 );
03492
03499 ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
03500
03508 explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03509
03517 ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03518
03535 inline Tp::PendingVariant *requestPropertyDisjointGroups() const
03536 {
03537 return internalRequestProperty(QLatin1String("DisjointGroups"));
03538 }
03539
03552 inline Tp::PendingVariant *requestPropertyGroupStorage() const
03553 {
03554 return internalRequestProperty(QLatin1String("GroupStorage"));
03555 }
03556
03580 inline Tp::PendingVariant *requestPropertyGroups() const
03581 {
03582 return internalRequestProperty(QLatin1String("Groups"));
03583 }
03584
03591 Tp::PendingVariantMap *requestAllProperties() const
03592 {
03593 return internalRequestAllProperties();
03594 }
03595
03596 public Q_SLOTS:
03645 inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
03646 {
03647 if (!invalidationReason().isEmpty()) {
03648 return QDBusPendingReply<>(QDBusMessage::createError(
03649 invalidationReason(),
03650 invalidationMessage()
03651 ));
03652 }
03653
03654 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03655 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
03656 callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
03657 return this->connection().asyncCall(callMessage, timeout);
03658 }
03659
03707 inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
03708 {
03709 if (!invalidationReason().isEmpty()) {
03710 return QDBusPendingReply<>(QDBusMessage::createError(
03711 invalidationReason(),
03712 invalidationMessage()
03713 ));
03714 }
03715
03716 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03717 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
03718 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03719 return this->connection().asyncCall(callMessage, timeout);
03720 }
03721
03762 inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03763 {
03764 if (!invalidationReason().isEmpty()) {
03765 return QDBusPendingReply<>(QDBusMessage::createError(
03766 invalidationReason(),
03767 invalidationMessage()
03768 ));
03769 }
03770
03771 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03772 this->staticInterfaceName(), QLatin1String("AddToGroup"));
03773 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03774 return this->connection().asyncCall(callMessage, timeout);
03775 }
03776
03816 inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03817 {
03818 if (!invalidationReason().isEmpty()) {
03819 return QDBusPendingReply<>(QDBusMessage::createError(
03820 invalidationReason(),
03821 invalidationMessage()
03822 ));
03823 }
03824
03825 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03826 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
03827 callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03828 return this->connection().asyncCall(callMessage, timeout);
03829 }
03830
03859 inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
03860 {
03861 if (!invalidationReason().isEmpty()) {
03862 return QDBusPendingReply<>(QDBusMessage::createError(
03863 invalidationReason(),
03864 invalidationMessage()
03865 ));
03866 }
03867
03868 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03869 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
03870 callMessage << QVariant::fromValue(group);
03871 return this->connection().asyncCall(callMessage, timeout);
03872 }
03873
03913 inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
03914 {
03915 if (!invalidationReason().isEmpty()) {
03916 return QDBusPendingReply<>(QDBusMessage::createError(
03917 invalidationReason(),
03918 invalidationMessage()
03919 ));
03920 }
03921
03922 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03923 this->staticInterfaceName(), QLatin1String("RenameGroup"));
03924 callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
03925 return this->connection().asyncCall(callMessage, timeout);
03926 }
03927
03928 Q_SIGNALS:
03946 void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
03947
03958 void GroupsCreated(const QStringList& names);
03959
04007 void GroupRenamed(const QString& oldName, const QString& newName);
04008
04035 void GroupsRemoved(const QStringList& names);
04036
04037 protected:
04038 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04039 };
04040
04048 class TP_QT_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
04049 {
04050 Q_OBJECT
04051
04052 public:
04059 static inline QLatin1String staticInterfaceName()
04060 {
04061 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
04062 }
04063
04071 ConnectionInterfaceContactInfoInterface(
04072 const QString& busName,
04073 const QString& objectPath,
04074 QObject* parent = 0
04075 );
04076
04085 ConnectionInterfaceContactInfoInterface(
04086 const QDBusConnection& connection,
04087 const QString& busName,
04088 const QString& objectPath,
04089 QObject* parent = 0
04090 );
04091
04098 ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
04099
04107 explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
04108
04116 ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04117
04141 inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
04142 {
04143 return internalRequestProperty(QLatin1String("ContactInfoFlags"));
04144 }
04145
04203 inline Tp::PendingVariant *requestPropertySupportedFields() const
04204 {
04205 return internalRequestProperty(QLatin1String("SupportedFields"));
04206 }
04207
04214 Tp::PendingVariantMap *requestAllProperties() const
04215 {
04216 return internalRequestAllProperties();
04217 }
04218
04219 public Q_SLOTS:
04242 inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04243 {
04244 if (!invalidationReason().isEmpty()) {
04245 return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
04246 invalidationReason(),
04247 invalidationMessage()
04248 ));
04249 }
04250
04251 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04252 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
04253 callMessage << QVariant::fromValue(contacts);
04254 return this->connection().asyncCall(callMessage, timeout);
04255 }
04256
04276 inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04277 {
04278 if (!invalidationReason().isEmpty()) {
04279 return QDBusPendingReply<>(QDBusMessage::createError(
04280 invalidationReason(),
04281 invalidationMessage()
04282 ));
04283 }
04284
04285 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04286 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
04287 callMessage << QVariant::fromValue(contacts);
04288 return this->connection().asyncCall(callMessage, timeout);
04289 }
04290
04312 inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
04313 {
04314 if (!invalidationReason().isEmpty()) {
04315 return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
04316 invalidationReason(),
04317 invalidationMessage()
04318 ));
04319 }
04320
04321 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04322 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
04323 callMessage << QVariant::fromValue(contact);
04324 return this->connection().asyncCall(callMessage, timeout);
04325 }
04326
04344 inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
04345 {
04346 if (!invalidationReason().isEmpty()) {
04347 return QDBusPendingReply<>(QDBusMessage::createError(
04348 invalidationReason(),
04349 invalidationMessage()
04350 ));
04351 }
04352
04353 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04354 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
04355 callMessage << QVariant::fromValue(contactInfo);
04356 return this->connection().asyncCall(callMessage, timeout);
04357 }
04358
04359 Q_SIGNALS:
04376 void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
04377
04378 protected:
04379 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04380 };
04381
04389 class TP_QT_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
04390 {
04391 Q_OBJECT
04392
04393 public:
04400 static inline QLatin1String staticInterfaceName()
04401 {
04402 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
04403 }
04404
04412 ConnectionInterfaceContactListInterface(
04413 const QString& busName,
04414 const QString& objectPath,
04415 QObject* parent = 0
04416 );
04417
04426 ConnectionInterfaceContactListInterface(
04427 const QDBusConnection& connection,
04428 const QString& busName,
04429 const QString& objectPath,
04430 QObject* parent = 0
04431 );
04432
04439 ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
04440
04448 explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
04449
04457 ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04458
04469 inline Tp::PendingVariant *requestPropertyContactListState() const
04470 {
04471 return internalRequestProperty(QLatin1String("ContactListState"));
04472 }
04473
04533 inline Tp::PendingVariant *requestPropertyContactListPersists() const
04534 {
04535 return internalRequestProperty(QLatin1String("ContactListPersists"));
04536 }
04537
04566 inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
04567 {
04568 return internalRequestProperty(QLatin1String("CanChangeContactList"));
04569 }
04570
04599 inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
04600 {
04601 return internalRequestProperty(QLatin1String("RequestUsesMessage"));
04602 }
04603
04610 Tp::PendingVariantMap *requestAllProperties() const
04611 {
04612 return internalRequestAllProperties();
04613 }
04614
04615 public Q_SLOTS:
04687 inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
04688 {
04689 if (!invalidationReason().isEmpty()) {
04690 return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04691 invalidationReason(),
04692 invalidationMessage()
04693 ));
04694 }
04695
04696 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04697 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
04698 callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04699 return this->connection().asyncCall(callMessage, timeout);
04700 }
04701
04812 inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
04813 {
04814 if (!invalidationReason().isEmpty()) {
04815 return QDBusPendingReply<>(QDBusMessage::createError(
04816 invalidationReason(),
04817 invalidationMessage()
04818 ));
04819 }
04820
04821 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04822 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
04823 callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
04824 return this->connection().asyncCall(callMessage, timeout);
04825 }
04826
04898 inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
04899 {
04900 if (!invalidationReason().isEmpty()) {
04901 return QDBusPendingReply<>(QDBusMessage::createError(
04902 invalidationReason(),
04903 invalidationMessage()
04904 ));
04905 }
04906
04907 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04908 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
04909 callMessage << QVariant::fromValue(contacts);
04910 return this->connection().asyncCall(callMessage, timeout);
04911 }
04912
04962 inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
04963 {
04964 if (!invalidationReason().isEmpty()) {
04965 return QDBusPendingReply<>(QDBusMessage::createError(
04966 invalidationReason(),
04967 invalidationMessage()
04968 ));
04969 }
04970
04971 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04972 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
04973 callMessage << QVariant::fromValue(contacts);
04974 return this->connection().asyncCall(callMessage, timeout);
04975 }
04976
05013 inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
05014 {
05015 if (!invalidationReason().isEmpty()) {
05016 return QDBusPendingReply<>(QDBusMessage::createError(
05017 invalidationReason(),
05018 invalidationMessage()
05019 ));
05020 }
05021
05022 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05023 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
05024 callMessage << QVariant::fromValue(contacts);
05025 return this->connection().asyncCall(callMessage, timeout);
05026 }
05027
05064 inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
05065 {
05066 if (!invalidationReason().isEmpty()) {
05067 return QDBusPendingReply<>(QDBusMessage::createError(
05068 invalidationReason(),
05069 invalidationMessage()
05070 ));
05071 }
05072
05073 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05074 this->staticInterfaceName(), QLatin1String("Unpublish"));
05075 callMessage << QVariant::fromValue(contacts);
05076 return this->connection().asyncCall(callMessage, timeout);
05077 }
05078
05079 Q_SIGNALS:
05089 void ContactListStateChanged(uint contactListState);
05090
05141 void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
05142
05165 void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
05166
05167 protected:
05168 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05169 };
05170
05178 class TP_QT_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
05179 {
05180 Q_OBJECT
05181
05182 public:
05189 static inline QLatin1String staticInterfaceName()
05190 {
05191 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
05192 }
05193
05201 ConnectionInterfaceContactsInterface(
05202 const QString& busName,
05203 const QString& objectPath,
05204 QObject* parent = 0
05205 );
05206
05215 ConnectionInterfaceContactsInterface(
05216 const QDBusConnection& connection,
05217 const QString& busName,
05218 const QString& objectPath,
05219 QObject* parent = 0
05220 );
05221
05228 ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
05229
05237 explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
05238
05246 ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05247
05258 inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
05259 {
05260 return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
05261 }
05262
05269 Tp::PendingVariantMap *requestAllProperties() const
05270 {
05271 return internalRequestAllProperties();
05272 }
05273
05274 public Q_SLOTS:
05357 inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
05358 {
05359 if (!invalidationReason().isEmpty()) {
05360 return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
05361 invalidationReason(),
05362 invalidationMessage()
05363 ));
05364 }
05365
05366 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05367 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
05368 callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
05369 return this->connection().asyncCall(callMessage, timeout);
05370 }
05371
05372 protected:
05373 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05374 };
05375
05383 class TP_QT_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
05384 {
05385 Q_OBJECT
05386
05387 public:
05394 static inline QLatin1String staticInterfaceName()
05395 {
05396 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
05397 }
05398
05406 ConnectionInterfaceLocationInterface(
05407 const QString& busName,
05408 const QString& objectPath,
05409 QObject* parent = 0
05410 );
05411
05420 ConnectionInterfaceLocationInterface(
05421 const QDBusConnection& connection,
05422 const QString& busName,
05423 const QString& objectPath,
05424 QObject* parent = 0
05425 );
05426
05433 ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
05434
05442 explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05443
05451 ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05452
05462 inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
05463 {
05464 return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
05465 }
05466
05479 inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
05480 {
05481 return internalRequestProperty(QLatin1String("LocationAccessControl"));
05482 }
05483
05496 inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
05497 {
05498 return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
05499 }
05500
05514 inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
05515 {
05516 return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
05517 }
05518
05525 Tp::PendingVariantMap *requestAllProperties() const
05526 {
05527 return internalRequestAllProperties();
05528 }
05529
05530 public Q_SLOTS:
05571 inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
05572 {
05573 if (!invalidationReason().isEmpty()) {
05574 return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
05575 invalidationReason(),
05576 invalidationMessage()
05577 ));
05578 }
05579
05580 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05581 this->staticInterfaceName(), QLatin1String("GetLocations"));
05582 callMessage << QVariant::fromValue(contacts);
05583 return this->connection().asyncCall(callMessage, timeout);
05584 }
05585
05610 inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
05611 {
05612 if (!invalidationReason().isEmpty()) {
05613 return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
05614 invalidationReason(),
05615 invalidationMessage()
05616 ));
05617 }
05618
05619 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05620 this->staticInterfaceName(), QLatin1String("RequestLocation"));
05621 callMessage << QVariant::fromValue(contact);
05622 return this->connection().asyncCall(callMessage, timeout);
05623 }
05624
05646 inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
05647 {
05648 if (!invalidationReason().isEmpty()) {
05649 return QDBusPendingReply<>(QDBusMessage::createError(
05650 invalidationReason(),
05651 invalidationMessage()
05652 ));
05653 }
05654
05655 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05656 this->staticInterfaceName(), QLatin1String("SetLocation"));
05657 callMessage << QVariant::fromValue(location);
05658 return this->connection().asyncCall(callMessage, timeout);
05659 }
05660
05661 Q_SIGNALS:
05676 void LocationUpdated(uint contact, const QVariantMap& location);
05677
05678 protected:
05679 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05680 };
05681
05689 class TP_QT_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
05690 {
05691 Q_OBJECT
05692
05693 public:
05700 static inline QLatin1String staticInterfaceName()
05701 {
05702 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
05703 }
05704
05712 ConnectionInterfaceMailNotificationInterface(
05713 const QString& busName,
05714 const QString& objectPath,
05715 QObject* parent = 0
05716 );
05717
05726 ConnectionInterfaceMailNotificationInterface(
05727 const QDBusConnection& connection,
05728 const QString& busName,
05729 const QString& objectPath,
05730 QObject* parent = 0
05731 );
05732
05739 ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
05740
05748 explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05749
05757 ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05758
05773 inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
05774 {
05775 return internalRequestProperty(QLatin1String("MailNotificationFlags"));
05776 }
05777
05802 inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
05803 {
05804 return internalRequestProperty(QLatin1String("UnreadMailCount"));
05805 }
05806
05823 inline Tp::PendingVariant *requestPropertyUnreadMails() const
05824 {
05825 return internalRequestProperty(QLatin1String("UnreadMails"));
05826 }
05827
05842 inline Tp::PendingVariant *requestPropertyMailAddress() const
05843 {
05844 return internalRequestProperty(QLatin1String("MailAddress"));
05845 }
05846
05853 Tp::PendingVariantMap *requestAllProperties() const
05854 {
05855 return internalRequestAllProperties();
05856 }
05857
05858 public Q_SLOTS:
05882 inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
05883 {
05884 if (!invalidationReason().isEmpty()) {
05885 return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05886 invalidationReason(),
05887 invalidationMessage()
05888 ));
05889 }
05890
05891 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05892 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
05893 return this->connection().asyncCall(callMessage, timeout);
05894 }
05895
05925 inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
05926 {
05927 if (!invalidationReason().isEmpty()) {
05928 return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05929 invalidationReason(),
05930 invalidationMessage()
05931 ));
05932 }
05933
05934 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05935 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
05936 callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
05937 return this->connection().asyncCall(callMessage, timeout);
05938 }
05939
05940 Q_SIGNALS:
05963 void MailsReceived(const Tp::MailList& mails);
05964
06006 void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
06007
06008 protected:
06009 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06010 };
06011
06019 class TP_QT_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
06020 {
06021 Q_OBJECT
06022
06023 public:
06030 static inline QLatin1String staticInterfaceName()
06031 {
06032 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
06033 }
06034
06042 ConnectionInterfacePowerSavingInterface(
06043 const QString& busName,
06044 const QString& objectPath,
06045 QObject* parent = 0
06046 );
06047
06056 ConnectionInterfacePowerSavingInterface(
06057 const QDBusConnection& connection,
06058 const QString& busName,
06059 const QString& objectPath,
06060 QObject* parent = 0
06061 );
06062
06069 ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
06070
06078 explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
06079
06087 ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06088
06104 inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
06105 {
06106 return internalRequestProperty(QLatin1String("PowerSavingActive"));
06107 }
06108
06115 Tp::PendingVariantMap *requestAllProperties() const
06116 {
06117 return internalRequestAllProperties();
06118 }
06119
06120 public Q_SLOTS:
06154 inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
06155 {
06156 if (!invalidationReason().isEmpty()) {
06157 return QDBusPendingReply<>(QDBusMessage::createError(
06158 invalidationReason(),
06159 invalidationMessage()
06160 ));
06161 }
06162
06163 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06164 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
06165 callMessage << QVariant::fromValue(activate);
06166 return this->connection().asyncCall(callMessage, timeout);
06167 }
06168
06169 Q_SIGNALS:
06182 void PowerSavingChanged(bool active);
06183
06184 protected:
06185 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06186 };
06187
06195 class TP_QT_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
06196 {
06197 Q_OBJECT
06198
06199 public:
06206 static inline QLatin1String staticInterfaceName()
06207 {
06208 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
06209 }
06210
06218 ConnectionInterfacePresenceInterface(
06219 const QString& busName,
06220 const QString& objectPath,
06221 QObject* parent = 0
06222 );
06223
06232 ConnectionInterfacePresenceInterface(
06233 const QDBusConnection& connection,
06234 const QString& busName,
06235 const QString& objectPath,
06236 QObject* parent = 0
06237 );
06238
06245 ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
06246
06254 explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06255
06263 ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06264
06271 Tp::PendingVariantMap *requestAllProperties() const
06272 {
06273 return internalRequestAllProperties();
06274 }
06275
06276 public Q_SLOTS:
06298 inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
06299 {
06300 if (!invalidationReason().isEmpty()) {
06301 return QDBusPendingReply<>(QDBusMessage::createError(
06302 invalidationReason(),
06303 invalidationMessage()
06304 ));
06305 }
06306
06307 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06308 this->staticInterfaceName(), QLatin1String("AddStatus"));
06309 callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
06310 return this->connection().asyncCall(callMessage, timeout);
06311 }
06312
06326 inline QDBusPendingReply<> ClearStatus(int timeout = -1)
06327 {
06328 if (!invalidationReason().isEmpty()) {
06329 return QDBusPendingReply<>(QDBusMessage::createError(
06330 invalidationReason(),
06331 invalidationMessage()
06332 ));
06333 }
06334
06335 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06336 this->staticInterfaceName(), QLatin1String("ClearStatus"));
06337 return this->connection().asyncCall(callMessage, timeout);
06338 }
06339
06363 inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
06364 {
06365 if (!invalidationReason().isEmpty()) {
06366 return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
06367 invalidationReason(),
06368 invalidationMessage()
06369 ));
06370 }
06371
06372 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06373 this->staticInterfaceName(), QLatin1String("GetPresence"));
06374 callMessage << QVariant::fromValue(contacts);
06375 return this->connection().asyncCall(callMessage, timeout);
06376 }
06377
06399 inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
06400 {
06401 if (!invalidationReason().isEmpty()) {
06402 return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
06403 invalidationReason(),
06404 invalidationMessage()
06405 ));
06406 }
06407
06408 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06409 this->staticInterfaceName(), QLatin1String("GetStatuses"));
06410 return this->connection().asyncCall(callMessage, timeout);
06411 }
06412
06431 inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
06432 {
06433 if (!invalidationReason().isEmpty()) {
06434 return QDBusPendingReply<>(QDBusMessage::createError(
06435 invalidationReason(),
06436 invalidationMessage()
06437 ));
06438 }
06439
06440 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06441 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
06442 callMessage << QVariant::fromValue(status);
06443 return this->connection().asyncCall(callMessage, timeout);
06444 }
06445
06464 inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
06465 {
06466 if (!invalidationReason().isEmpty()) {
06467 return QDBusPendingReply<>(QDBusMessage::createError(
06468 invalidationReason(),
06469 invalidationMessage()
06470 ));
06471 }
06472
06473 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06474 this->staticInterfaceName(), QLatin1String("RequestPresence"));
06475 callMessage << QVariant::fromValue(contacts);
06476 return this->connection().asyncCall(callMessage, timeout);
06477 }
06478
06494 inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
06495 {
06496 if (!invalidationReason().isEmpty()) {
06497 return QDBusPendingReply<>(QDBusMessage::createError(
06498 invalidationReason(),
06499 invalidationMessage()
06500 ));
06501 }
06502
06503 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06504 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
06505 callMessage << QVariant::fromValue(time);
06506 return this->connection().asyncCall(callMessage, timeout);
06507 }
06508
06546 inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
06547 {
06548 if (!invalidationReason().isEmpty()) {
06549 return QDBusPendingReply<>(QDBusMessage::createError(
06550 invalidationReason(),
06551 invalidationMessage()
06552 ));
06553 }
06554
06555 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06556 this->staticInterfaceName(), QLatin1String("SetStatus"));
06557 callMessage << QVariant::fromValue(statuses);
06558 return this->connection().asyncCall(callMessage, timeout);
06559 }
06560
06561 Q_SIGNALS:
06578 void PresenceUpdate(const Tp::ContactPresences& presence);
06579
06580 protected:
06581 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06582 };
06583
06591 class TP_QT_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
06592 {
06593 Q_OBJECT
06594
06595 public:
06602 static inline QLatin1String staticInterfaceName()
06603 {
06604 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
06605 }
06606
06614 ConnectionInterfaceRequestsInterface(
06615 const QString& busName,
06616 const QString& objectPath,
06617 QObject* parent = 0
06618 );
06619
06628 ConnectionInterfaceRequestsInterface(
06629 const QDBusConnection& connection,
06630 const QString& busName,
06631 const QString& objectPath,
06632 QObject* parent = 0
06633 );
06634
06641 ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
06642
06650 explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
06651
06659 ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06660
06671 inline Tp::PendingVariant *requestPropertyChannels() const
06672 {
06673 return internalRequestProperty(QLatin1String("Channels"));
06674 }
06675
06705 inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
06706 {
06707 return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
06708 }
06709
06716 Tp::PendingVariantMap *requestAllProperties() const
06717 {
06718 return internalRequestAllProperties();
06719 }
06720
06721 public Q_SLOTS:
06803 inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
06804 {
06805 if (!invalidationReason().isEmpty()) {
06806 return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06807 invalidationReason(),
06808 invalidationMessage()
06809 ));
06810 }
06811
06812 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06813 this->staticInterfaceName(), QLatin1String("CreateChannel"));
06814 callMessage << QVariant::fromValue(request);
06815 return this->connection().asyncCall(callMessage, timeout);
06816 }
06817
06882 inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
06883 {
06884 if (!invalidationReason().isEmpty()) {
06885 return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06886 invalidationReason(),
06887 invalidationMessage()
06888 ));
06889 }
06890
06891 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06892 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
06893 callMessage << QVariant::fromValue(request);
06894 return this->connection().asyncCall(callMessage, timeout);
06895 }
06896
06897 Q_SIGNALS:
06941 void NewChannels(const Tp::ChannelDetailsList& channels);
06942
06955 void ChannelClosed(const QDBusObjectPath& removed);
06956
06957 protected:
06958 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06959 };
06960
06968 class TP_QT_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
06969 {
06970 Q_OBJECT
06971
06972 public:
06979 static inline QLatin1String staticInterfaceName()
06980 {
06981 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
06982 }
06983
06991 ConnectionInterfaceServicePointInterface(
06992 const QString& busName,
06993 const QString& objectPath,
06994 QObject* parent = 0
06995 );
06996
07005 ConnectionInterfaceServicePointInterface(
07006 const QDBusConnection& connection,
07007 const QString& busName,
07008 const QString& objectPath,
07009 QObject* parent = 0
07010 );
07011
07018 ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
07019
07027 explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
07028
07036 ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07037
07049 inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
07050 {
07051 return internalRequestProperty(QLatin1String("KnownServicePoints"));
07052 }
07053
07060 Tp::PendingVariantMap *requestAllProperties() const
07061 {
07062 return internalRequestAllProperties();
07063 }
07064
07065 Q_SIGNALS:
07079 void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
07080
07081 protected:
07082 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07083 };
07084
07092 class TP_QT_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
07093 {
07094 Q_OBJECT
07095
07096 public:
07103 static inline QLatin1String staticInterfaceName()
07104 {
07105 return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
07106 }
07107
07115 ConnectionInterfaceSimplePresenceInterface(
07116 const QString& busName,
07117 const QString& objectPath,
07118 QObject* parent = 0
07119 );
07120
07129 ConnectionInterfaceSimplePresenceInterface(
07130 const QDBusConnection& connection,
07131 const QString& busName,
07132 const QString& objectPath,
07133 QObject* parent = 0
07134 );
07135
07142 ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
07143
07151 explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
07152
07160 ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07161
07203 inline Tp::PendingVariant *requestPropertyStatuses() const
07204 {
07205 return internalRequestProperty(QLatin1String("Statuses"));
07206 }
07207
07252 inline Tp::PendingVariant *requestPropertyMaximumStatusMessageLength() const
07253 {
07254 return internalRequestProperty(QLatin1String("MaximumStatusMessageLength"));
07255 }
07256
07263 Tp::PendingVariantMap *requestAllProperties() const
07264 {
07265 return internalRequestAllProperties();
07266 }
07267
07268 public Q_SLOTS:
07332 inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
07333 {
07334 if (!invalidationReason().isEmpty()) {
07335 return QDBusPendingReply<>(QDBusMessage::createError(
07336 invalidationReason(),
07337 invalidationMessage()
07338 ));
07339 }
07340
07341 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07342 this->staticInterfaceName(), QLatin1String("SetPresence"));
07343 callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
07344 return this->connection().asyncCall(callMessage, timeout);
07345 }
07346
07378 inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
07379 {
07380 if (!invalidationReason().isEmpty()) {
07381 return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
07382 invalidationReason(),
07383 invalidationMessage()
07384 ));
07385 }
07386
07387 QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07388 this->staticInterfaceName(), QLatin1String("GetPresences"));
07389 callMessage << QVariant::fromValue(contacts);
07390 return this->connection().asyncCall(callMessage, timeout);
07391 }
07392
07393 Q_SIGNALS:
07406 void PresencesChanged(const Tp::SimpleContactPresences& presence);
07407
07408 protected:
07409 virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07410 };
07411 }
07412 }
07413 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
07414 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
07415 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
07416 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
07417 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
07418 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
07419 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
07420 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
07421 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
07422 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
07423 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
07424 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
07425 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
07426 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
07427 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
07428 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
07429 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
07430 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
07431 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
07432 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
07433 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)