Home · All Classes · All Namespaces · Modules · Functions · Files
cli-connection.h
00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt-client-gen.py.
00003  *
00004  * This file can be distributed under the same terms as the specification from
00005  * which it was generated.
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*)


Copyright © 2008-2011 Collabora Ltd. and Nokia Corporation
Telepathy-Qt 0.9.0