Home · All Classes · All Namespaces · Modules · Functions · Files
cli-connection.h
00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt4-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_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011 
00012 #include <TelepathyQt4/Types>
00013 
00014 #include <QtGlobal>
00015 
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019 
00020 #include <QDBusPendingReply>
00021 
00022 #include <TelepathyQt4/AbstractInterface>
00023 #include <TelepathyQt4/DBusProxy>
00024 #include <TelepathyQt4/Global>
00025 
00026 namespace Tp
00027 {
00028 class PendingVariant;
00029 class PendingOperation;
00030 }
00031 
00032 namespace Tp
00033 {
00034 namespace Client
00035 {
00036 
00044 class TELEPATHY_QT4_EXPORT ConnectionInterface : public Tp::AbstractInterface
00045 {
00046     Q_OBJECT
00047 
00048 public:
00055     static inline QLatin1String staticInterfaceName()
00056     {
00057         return QLatin1String("org.freedesktop.Telepathy.Connection");
00058     }
00059 
00067     ConnectionInterface(
00068         const QString& busName,
00069         const QString& objectPath,
00070         QObject* parent = 0
00071     );
00072 
00081     ConnectionInterface(
00082         const QDBusConnection& connection,
00083         const QString& busName,
00084         const QString& objectPath,
00085         QObject* parent = 0
00086     );
00087 
00094     ConnectionInterface(Tp::DBusProxy *proxy);
00095 
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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 
02068     Tp::PendingVariantMap *requestAllProperties() const
02069     {
02070         return internalRequestAllProperties();
02071     }
02072 
02073 Q_SIGNALS:
02088     void BalanceChanged(const Tp::CurrencyAmount& balance);
02089 
02090 protected:
02091     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02092 };
02093 
02101 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
02102 {
02103     Q_OBJECT
02104 
02105 public:
02112     static inline QLatin1String staticInterfaceName()
02113     {
02114         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
02115     }
02116 
02124     ConnectionInterfaceCapabilitiesInterface(
02125         const QString& busName,
02126         const QString& objectPath,
02127         QObject* parent = 0
02128     );
02129 
02138     ConnectionInterfaceCapabilitiesInterface(
02139         const QDBusConnection& connection,
02140         const QString& busName,
02141         const QString& objectPath,
02142         QObject* parent = 0
02143     );
02144 
02151     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
02152 
02160     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02161 
02169     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02170 
02177     Tp::PendingVariantMap *requestAllProperties() const
02178     {
02179         return internalRequestAllProperties();
02180     }
02181 
02182 public Q_SLOTS:
02236     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
02237     {
02238         if (!invalidationReason().isEmpty()) {
02239             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
02240                 invalidationReason(),
02241                 invalidationMessage()
02242             ));
02243         }
02244 
02245         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02246                 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
02247         callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
02248         return this->connection().asyncCall(callMessage, timeout);
02249     }
02250 
02285     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
02286     {
02287         if (!invalidationReason().isEmpty()) {
02288             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
02289                 invalidationReason(),
02290                 invalidationMessage()
02291             ));
02292         }
02293 
02294         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02295                 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
02296         callMessage << QVariant::fromValue(handles);
02297         return this->connection().asyncCall(callMessage, timeout);
02298     }
02299 
02300 Q_SIGNALS:
02327     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
02328 
02329 protected:
02330     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02331 };
02332 
02340 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
02341 {
02342     Q_OBJECT
02343 
02344 public:
02351     static inline QLatin1String staticInterfaceName()
02352     {
02353         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
02354     }
02355 
02363     ConnectionInterfaceCellularInterface(
02364         const QString& busName,
02365         const QString& objectPath,
02366         QObject* parent = 0
02367     );
02368 
02377     ConnectionInterfaceCellularInterface(
02378         const QDBusConnection& connection,
02379         const QString& busName,
02380         const QString& objectPath,
02381         QObject* parent = 0
02382     );
02383 
02390     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02391 
02399     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02400 
02408     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02409 
02428     inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
02429     {
02430         return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
02431     }
02432 
02451     inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
02452     {
02453         return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
02454     }
02455 
02478     inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
02479     {
02480         return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
02481     }
02482 
02505     inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
02506     {
02507         return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
02508     }
02509 
02526     inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
02527     {
02528         return internalRequestProperty(QLatin1String("MessageServiceCentre"));
02529     }
02530 
02547     inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
02548     {
02549         return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
02550     }
02551 
02565     inline Tp::PendingVariant *requestPropertyIMSI() const
02566     {
02567         return internalRequestProperty(QLatin1String("IMSI"));
02568     }
02569 
02588     inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
02589     {
02590         return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
02591     }
02592 
02611     inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
02612     {
02613         return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
02614     }
02615 
02641     inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
02642     {
02643         return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
02644     }
02645 
02671     inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
02672     {
02673         return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
02674     }
02675 
02682     Tp::PendingVariantMap *requestAllProperties() const
02683     {
02684         return internalRequestAllProperties();
02685     }
02686 
02687 Q_SIGNALS:
02703     void IMSIChanged(const QString& IMSI);
02704 
02705 protected:
02706     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02707 };
02708 
02716 class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
02717 {
02718     Q_OBJECT
02719 
02720 public:
02727     static inline QLatin1String staticInterfaceName()
02728     {
02729         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
02730     }
02731 
02739     ConnectionInterfaceClientTypesInterface(
02740         const QString& busName,
02741         const QString& objectPath,
02742         QObject* parent = 0
02743     );
02744 
02753     ConnectionInterfaceClientTypesInterface(
02754         const QDBusConnection& connection,
02755         const QString& busName,
02756         const QString& objectPath,
02757         QObject* parent = 0
02758     );
02759 
02766     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
02767 
02775     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02776 
02784     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02785 
02792     Tp::PendingVariantMap *requestAllProperties() const
02793     {
02794         return internalRequestAllProperties();
02795     }
02796 
02797 public Q_SLOTS:
02826     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
02827     {
02828         if (!invalidationReason().isEmpty()) {
02829             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
02830                 invalidationReason(),
02831                 invalidationMessage()
02832             ));
02833         }
02834 
02835         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02836                 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
02837         callMessage << QVariant::fromValue(contacts);
02838         return this->connection().asyncCall(callMessage, timeout);
02839     }
02840 
02865     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
02866     {
02867         if (!invalidationReason().isEmpty()) {
02868             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02869                 invalidationReason(),
02870                 invalidationMessage()
02871             ));
02872         }
02873 
02874         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02875                 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
02876         callMessage << QVariant::fromValue(contact);
02877         return this->connection().asyncCall(callMessage, timeout);
02878     }
02879 
02880 Q_SIGNALS:
02895     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
02896 
02897 protected:
02898     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02899 };
02900 
02908 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
02909 {
02910     Q_OBJECT
02911 
02912 public:
02919     static inline QLatin1String staticInterfaceName()
02920     {
02921         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
02922     }
02923 
02931     ConnectionInterfaceContactBlockingInterface(
02932         const QString& busName,
02933         const QString& objectPath,
02934         QObject* parent = 0
02935     );
02936 
02945     ConnectionInterfaceContactBlockingInterface(
02946         const QDBusConnection& connection,
02947         const QString& busName,
02948         const QString& objectPath,
02949         QObject* parent = 0
02950     );
02951 
02958     ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
02959 
02967     explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
02968 
02976     ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02977 
02994     inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
02995     {
02996         return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
02997     }
02998 
03005     Tp::PendingVariantMap *requestAllProperties() const
03006     {
03007         return internalRequestAllProperties();
03008     }
03009 
03010 public Q_SLOTS:
03070     inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
03071     {
03072         if (!invalidationReason().isEmpty()) {
03073             return QDBusPendingReply<>(QDBusMessage::createError(
03074                 invalidationReason(),
03075                 invalidationMessage()
03076             ));
03077         }
03078 
03079         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03080                 this->staticInterfaceName(), QLatin1String("BlockContacts"));
03081         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
03082         return this->connection().asyncCall(callMessage, timeout);
03083     }
03084 
03103     inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
03104     {
03105         if (!invalidationReason().isEmpty()) {
03106             return QDBusPendingReply<>(QDBusMessage::createError(
03107                 invalidationReason(),
03108                 invalidationMessage()
03109             ));
03110         }
03111 
03112         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03113                 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
03114         callMessage << QVariant::fromValue(contacts);
03115         return this->connection().asyncCall(callMessage, timeout);
03116     }
03117 
03138     inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
03139     {
03140         if (!invalidationReason().isEmpty()) {
03141             return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
03142                 invalidationReason(),
03143                 invalidationMessage()
03144             ));
03145         }
03146 
03147         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03148                 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
03149         return this->connection().asyncCall(callMessage, timeout);
03150     }
03151 
03152 Q_SIGNALS:
03171     void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
03172 
03173 protected:
03174     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03175 };
03176 
03184 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
03185 {
03186     Q_OBJECT
03187 
03188 public:
03195     static inline QLatin1String staticInterfaceName()
03196     {
03197         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
03198     }
03199 
03207     ConnectionInterfaceContactCapabilitiesInterface(
03208         const QString& busName,
03209         const QString& objectPath,
03210         QObject* parent = 0
03211     );
03212 
03221     ConnectionInterfaceContactCapabilitiesInterface(
03222         const QDBusConnection& connection,
03223         const QString& busName,
03224         const QString& objectPath,
03225         QObject* parent = 0
03226     );
03227 
03234     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
03235 
03243     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
03244 
03252     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03253 
03260     Tp::PendingVariantMap *requestAllProperties() const
03261     {
03262         return internalRequestAllProperties();
03263     }
03264 
03265 public Q_SLOTS:
03328     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
03329     {
03330         if (!invalidationReason().isEmpty()) {
03331             return QDBusPendingReply<>(QDBusMessage::createError(
03332                 invalidationReason(),
03333                 invalidationMessage()
03334             ));
03335         }
03336 
03337         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03338                 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
03339         callMessage << QVariant::fromValue(handlerCapabilities);
03340         return this->connection().asyncCall(callMessage, timeout);
03341     }
03342 
03378     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
03379     {
03380         if (!invalidationReason().isEmpty()) {
03381             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
03382                 invalidationReason(),
03383                 invalidationMessage()
03384             ));
03385         }
03386 
03387         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03388                 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
03389         callMessage << QVariant::fromValue(handles);
03390         return this->connection().asyncCall(callMessage, timeout);
03391     }
03392 
03393 Q_SIGNALS:
03414     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
03415 
03416 protected:
03417     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03418 };
03419 
03427 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
03428 {
03429     Q_OBJECT
03430 
03431 public:
03438     static inline QLatin1String staticInterfaceName()
03439     {
03440         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
03441     }
03442 
03450     ConnectionInterfaceContactGroupsInterface(
03451         const QString& busName,
03452         const QString& objectPath,
03453         QObject* parent = 0
03454     );
03455 
03464     ConnectionInterfaceContactGroupsInterface(
03465         const QDBusConnection& connection,
03466         const QString& busName,
03467         const QString& objectPath,
03468         QObject* parent = 0
03469     );
03470 
03477     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
03478 
03486     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03487 
03495     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03496 
03513     inline Tp::PendingVariant *requestPropertyDisjointGroups() const
03514     {
03515         return internalRequestProperty(QLatin1String("DisjointGroups"));
03516     }
03517 
03530     inline Tp::PendingVariant *requestPropertyGroupStorage() const
03531     {
03532         return internalRequestProperty(QLatin1String("GroupStorage"));
03533     }
03534 
03558     inline Tp::PendingVariant *requestPropertyGroups() const
03559     {
03560         return internalRequestProperty(QLatin1String("Groups"));
03561     }
03562 
03569     Tp::PendingVariantMap *requestAllProperties() const
03570     {
03571         return internalRequestAllProperties();
03572     }
03573 
03574 public Q_SLOTS:
03623     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
03624     {
03625         if (!invalidationReason().isEmpty()) {
03626             return QDBusPendingReply<>(QDBusMessage::createError(
03627                 invalidationReason(),
03628                 invalidationMessage()
03629             ));
03630         }
03631 
03632         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03633                 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
03634         callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
03635         return this->connection().asyncCall(callMessage, timeout);
03636     }
03637 
03685     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
03686     {
03687         if (!invalidationReason().isEmpty()) {
03688             return QDBusPendingReply<>(QDBusMessage::createError(
03689                 invalidationReason(),
03690                 invalidationMessage()
03691             ));
03692         }
03693 
03694         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03695                 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
03696         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03697         return this->connection().asyncCall(callMessage, timeout);
03698     }
03699 
03740     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03741     {
03742         if (!invalidationReason().isEmpty()) {
03743             return QDBusPendingReply<>(QDBusMessage::createError(
03744                 invalidationReason(),
03745                 invalidationMessage()
03746             ));
03747         }
03748 
03749         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03750                 this->staticInterfaceName(), QLatin1String("AddToGroup"));
03751         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03752         return this->connection().asyncCall(callMessage, timeout);
03753     }
03754 
03794     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03795     {
03796         if (!invalidationReason().isEmpty()) {
03797             return QDBusPendingReply<>(QDBusMessage::createError(
03798                 invalidationReason(),
03799                 invalidationMessage()
03800             ));
03801         }
03802 
03803         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03804                 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
03805         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03806         return this->connection().asyncCall(callMessage, timeout);
03807     }
03808 
03837     inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
03838     {
03839         if (!invalidationReason().isEmpty()) {
03840             return QDBusPendingReply<>(QDBusMessage::createError(
03841                 invalidationReason(),
03842                 invalidationMessage()
03843             ));
03844         }
03845 
03846         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03847                 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
03848         callMessage << QVariant::fromValue(group);
03849         return this->connection().asyncCall(callMessage, timeout);
03850     }
03851 
03891     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
03892     {
03893         if (!invalidationReason().isEmpty()) {
03894             return QDBusPendingReply<>(QDBusMessage::createError(
03895                 invalidationReason(),
03896                 invalidationMessage()
03897             ));
03898         }
03899 
03900         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03901                 this->staticInterfaceName(), QLatin1String("RenameGroup"));
03902         callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
03903         return this->connection().asyncCall(callMessage, timeout);
03904     }
03905 
03906 Q_SIGNALS:
03924     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
03925 
03936     void GroupsCreated(const QStringList& names);
03937 
03985     void GroupRenamed(const QString& oldName, const QString& newName);
03986 
04013     void GroupsRemoved(const QStringList& names);
04014 
04015 protected:
04016     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04017 };
04018 
04026 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
04027 {
04028     Q_OBJECT
04029 
04030 public:
04037     static inline QLatin1String staticInterfaceName()
04038     {
04039         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
04040     }
04041 
04049     ConnectionInterfaceContactInfoInterface(
04050         const QString& busName,
04051         const QString& objectPath,
04052         QObject* parent = 0
04053     );
04054 
04063     ConnectionInterfaceContactInfoInterface(
04064         const QDBusConnection& connection,
04065         const QString& busName,
04066         const QString& objectPath,
04067         QObject* parent = 0
04068     );
04069 
04076     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
04077 
04085     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
04086 
04094     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04095 
04119     inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
04120     {
04121         return internalRequestProperty(QLatin1String("ContactInfoFlags"));
04122     }
04123 
04181     inline Tp::PendingVariant *requestPropertySupportedFields() const
04182     {
04183         return internalRequestProperty(QLatin1String("SupportedFields"));
04184     }
04185 
04192     Tp::PendingVariantMap *requestAllProperties() const
04193     {
04194         return internalRequestAllProperties();
04195     }
04196 
04197 public Q_SLOTS:
04220     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04221     {
04222         if (!invalidationReason().isEmpty()) {
04223             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
04224                 invalidationReason(),
04225                 invalidationMessage()
04226             ));
04227         }
04228 
04229         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04230                 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
04231         callMessage << QVariant::fromValue(contacts);
04232         return this->connection().asyncCall(callMessage, timeout);
04233     }
04234 
04254     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04255     {
04256         if (!invalidationReason().isEmpty()) {
04257             return QDBusPendingReply<>(QDBusMessage::createError(
04258                 invalidationReason(),
04259                 invalidationMessage()
04260             ));
04261         }
04262 
04263         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04264                 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
04265         callMessage << QVariant::fromValue(contacts);
04266         return this->connection().asyncCall(callMessage, timeout);
04267     }
04268 
04290     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
04291     {
04292         if (!invalidationReason().isEmpty()) {
04293             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
04294                 invalidationReason(),
04295                 invalidationMessage()
04296             ));
04297         }
04298 
04299         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04300                 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
04301         callMessage << QVariant::fromValue(contact);
04302         return this->connection().asyncCall(callMessage, timeout);
04303     }
04304 
04322     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
04323     {
04324         if (!invalidationReason().isEmpty()) {
04325             return QDBusPendingReply<>(QDBusMessage::createError(
04326                 invalidationReason(),
04327                 invalidationMessage()
04328             ));
04329         }
04330 
04331         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04332                 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
04333         callMessage << QVariant::fromValue(contactInfo);
04334         return this->connection().asyncCall(callMessage, timeout);
04335     }
04336 
04337 Q_SIGNALS:
04354     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
04355 
04356 protected:
04357     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04358 };
04359 
04367 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
04368 {
04369     Q_OBJECT
04370 
04371 public:
04378     static inline QLatin1String staticInterfaceName()
04379     {
04380         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
04381     }
04382 
04390     ConnectionInterfaceContactListInterface(
04391         const QString& busName,
04392         const QString& objectPath,
04393         QObject* parent = 0
04394     );
04395 
04404     ConnectionInterfaceContactListInterface(
04405         const QDBusConnection& connection,
04406         const QString& busName,
04407         const QString& objectPath,
04408         QObject* parent = 0
04409     );
04410 
04417     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
04418 
04426     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
04427 
04435     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04436 
04447     inline Tp::PendingVariant *requestPropertyContactListState() const
04448     {
04449         return internalRequestProperty(QLatin1String("ContactListState"));
04450     }
04451 
04511     inline Tp::PendingVariant *requestPropertyContactListPersists() const
04512     {
04513         return internalRequestProperty(QLatin1String("ContactListPersists"));
04514     }
04515 
04544     inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
04545     {
04546         return internalRequestProperty(QLatin1String("CanChangeContactList"));
04547     }
04548 
04577     inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
04578     {
04579         return internalRequestProperty(QLatin1String("RequestUsesMessage"));
04580     }
04581 
04588     Tp::PendingVariantMap *requestAllProperties() const
04589     {
04590         return internalRequestAllProperties();
04591     }
04592 
04593 public Q_SLOTS:
04665     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
04666     {
04667         if (!invalidationReason().isEmpty()) {
04668             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04669                 invalidationReason(),
04670                 invalidationMessage()
04671             ));
04672         }
04673 
04674         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04675                 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
04676         callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04677         return this->connection().asyncCall(callMessage, timeout);
04678     }
04679 
04790     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
04791     {
04792         if (!invalidationReason().isEmpty()) {
04793             return QDBusPendingReply<>(QDBusMessage::createError(
04794                 invalidationReason(),
04795                 invalidationMessage()
04796             ));
04797         }
04798 
04799         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04800                 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
04801         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
04802         return this->connection().asyncCall(callMessage, timeout);
04803     }
04804 
04876     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
04877     {
04878         if (!invalidationReason().isEmpty()) {
04879             return QDBusPendingReply<>(QDBusMessage::createError(
04880                 invalidationReason(),
04881                 invalidationMessage()
04882             ));
04883         }
04884 
04885         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04886                 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
04887         callMessage << QVariant::fromValue(contacts);
04888         return this->connection().asyncCall(callMessage, timeout);
04889     }
04890 
04940     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
04941     {
04942         if (!invalidationReason().isEmpty()) {
04943             return QDBusPendingReply<>(QDBusMessage::createError(
04944                 invalidationReason(),
04945                 invalidationMessage()
04946             ));
04947         }
04948 
04949         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04950                 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
04951         callMessage << QVariant::fromValue(contacts);
04952         return this->connection().asyncCall(callMessage, timeout);
04953     }
04954 
04991     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
04992     {
04993         if (!invalidationReason().isEmpty()) {
04994             return QDBusPendingReply<>(QDBusMessage::createError(
04995                 invalidationReason(),
04996                 invalidationMessage()
04997             ));
04998         }
04999 
05000         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05001                 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
05002         callMessage << QVariant::fromValue(contacts);
05003         return this->connection().asyncCall(callMessage, timeout);
05004     }
05005 
05042     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
05043     {
05044         if (!invalidationReason().isEmpty()) {
05045             return QDBusPendingReply<>(QDBusMessage::createError(
05046                 invalidationReason(),
05047                 invalidationMessage()
05048             ));
05049         }
05050 
05051         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05052                 this->staticInterfaceName(), QLatin1String("Unpublish"));
05053         callMessage << QVariant::fromValue(contacts);
05054         return this->connection().asyncCall(callMessage, timeout);
05055     }
05056 
05057 Q_SIGNALS:
05067     void ContactListStateChanged(uint contactListState);
05068 
05119     void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
05120 
05143     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
05144 
05145 protected:
05146     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05147 };
05148 
05156 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
05157 {
05158     Q_OBJECT
05159 
05160 public:
05167     static inline QLatin1String staticInterfaceName()
05168     {
05169         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
05170     }
05171 
05179     ConnectionInterfaceContactsInterface(
05180         const QString& busName,
05181         const QString& objectPath,
05182         QObject* parent = 0
05183     );
05184 
05193     ConnectionInterfaceContactsInterface(
05194         const QDBusConnection& connection,
05195         const QString& busName,
05196         const QString& objectPath,
05197         QObject* parent = 0
05198     );
05199 
05206     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
05207 
05215     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
05216 
05224     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05225 
05236     inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
05237     {
05238         return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
05239     }
05240 
05247     Tp::PendingVariantMap *requestAllProperties() const
05248     {
05249         return internalRequestAllProperties();
05250     }
05251 
05252 public Q_SLOTS:
05335     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
05336     {
05337         if (!invalidationReason().isEmpty()) {
05338             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
05339                 invalidationReason(),
05340                 invalidationMessage()
05341             ));
05342         }
05343 
05344         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05345                 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
05346         callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
05347         return this->connection().asyncCall(callMessage, timeout);
05348     }
05349 
05350 protected:
05351     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05352 };
05353 
05361 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
05362 {
05363     Q_OBJECT
05364 
05365 public:
05372     static inline QLatin1String staticInterfaceName()
05373     {
05374         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
05375     }
05376 
05384     ConnectionInterfaceLocationInterface(
05385         const QString& busName,
05386         const QString& objectPath,
05387         QObject* parent = 0
05388     );
05389 
05398     ConnectionInterfaceLocationInterface(
05399         const QDBusConnection& connection,
05400         const QString& busName,
05401         const QString& objectPath,
05402         QObject* parent = 0
05403     );
05404 
05411     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
05412 
05420     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05421 
05429     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05430 
05440     inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
05441     {
05442         return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
05443     }
05444 
05457     inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
05458     {
05459         return internalRequestProperty(QLatin1String("LocationAccessControl"));
05460     }
05461 
05474     inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
05475     {
05476         return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
05477     }
05478 
05492     inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
05493     {
05494         return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
05495     }
05496 
05503     Tp::PendingVariantMap *requestAllProperties() const
05504     {
05505         return internalRequestAllProperties();
05506     }
05507 
05508 public Q_SLOTS:
05549     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
05550     {
05551         if (!invalidationReason().isEmpty()) {
05552             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
05553                 invalidationReason(),
05554                 invalidationMessage()
05555             ));
05556         }
05557 
05558         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05559                 this->staticInterfaceName(), QLatin1String("GetLocations"));
05560         callMessage << QVariant::fromValue(contacts);
05561         return this->connection().asyncCall(callMessage, timeout);
05562     }
05563 
05588     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
05589     {
05590         if (!invalidationReason().isEmpty()) {
05591             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
05592                 invalidationReason(),
05593                 invalidationMessage()
05594             ));
05595         }
05596 
05597         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05598                 this->staticInterfaceName(), QLatin1String("RequestLocation"));
05599         callMessage << QVariant::fromValue(contact);
05600         return this->connection().asyncCall(callMessage, timeout);
05601     }
05602 
05624     inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
05625     {
05626         if (!invalidationReason().isEmpty()) {
05627             return QDBusPendingReply<>(QDBusMessage::createError(
05628                 invalidationReason(),
05629                 invalidationMessage()
05630             ));
05631         }
05632 
05633         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05634                 this->staticInterfaceName(), QLatin1String("SetLocation"));
05635         callMessage << QVariant::fromValue(location);
05636         return this->connection().asyncCall(callMessage, timeout);
05637     }
05638 
05639 Q_SIGNALS:
05654     void LocationUpdated(uint contact, const QVariantMap& location);
05655 
05656 protected:
05657     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05658 };
05659 
05667 class TELEPATHY_QT4_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
05668 {
05669     Q_OBJECT
05670 
05671 public:
05678     static inline QLatin1String staticInterfaceName()
05679     {
05680         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
05681     }
05682 
05690     ConnectionInterfaceMailNotificationInterface(
05691         const QString& busName,
05692         const QString& objectPath,
05693         QObject* parent = 0
05694     );
05695 
05704     ConnectionInterfaceMailNotificationInterface(
05705         const QDBusConnection& connection,
05706         const QString& busName,
05707         const QString& objectPath,
05708         QObject* parent = 0
05709     );
05710 
05717     ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
05718 
05726     explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05727 
05735     ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05736 
05751     inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
05752     {
05753         return internalRequestProperty(QLatin1String("MailNotificationFlags"));
05754     }
05755 
05780     inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
05781     {
05782         return internalRequestProperty(QLatin1String("UnreadMailCount"));
05783     }
05784 
05801     inline Tp::PendingVariant *requestPropertyUnreadMails() const
05802     {
05803         return internalRequestProperty(QLatin1String("UnreadMails"));
05804     }
05805 
05820     inline Tp::PendingVariant *requestPropertyMailAddress() const
05821     {
05822         return internalRequestProperty(QLatin1String("MailAddress"));
05823     }
05824 
05831     Tp::PendingVariantMap *requestAllProperties() const
05832     {
05833         return internalRequestAllProperties();
05834     }
05835 
05836 public Q_SLOTS:
05860     inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
05861     {
05862         if (!invalidationReason().isEmpty()) {
05863             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05864                 invalidationReason(),
05865                 invalidationMessage()
05866             ));
05867         }
05868 
05869         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05870                 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
05871         return this->connection().asyncCall(callMessage, timeout);
05872     }
05873 
05903     inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
05904     {
05905         if (!invalidationReason().isEmpty()) {
05906             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05907                 invalidationReason(),
05908                 invalidationMessage()
05909             ));
05910         }
05911 
05912         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05913                 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
05914         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
05915         return this->connection().asyncCall(callMessage, timeout);
05916     }
05917 
05918 Q_SIGNALS:
05941     void MailsReceived(const Tp::MailList& mails);
05942 
05984     void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
05985 
05986 protected:
05987     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05988 };
05989 
05997 class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
05998 {
05999     Q_OBJECT
06000 
06001 public:
06008     static inline QLatin1String staticInterfaceName()
06009     {
06010         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
06011     }
06012 
06020     ConnectionInterfacePowerSavingInterface(
06021         const QString& busName,
06022         const QString& objectPath,
06023         QObject* parent = 0
06024     );
06025 
06034     ConnectionInterfacePowerSavingInterface(
06035         const QDBusConnection& connection,
06036         const QString& busName,
06037         const QString& objectPath,
06038         QObject* parent = 0
06039     );
06040 
06047     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
06048 
06056     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
06057 
06065     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06066 
06082     inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
06083     {
06084         return internalRequestProperty(QLatin1String("PowerSavingActive"));
06085     }
06086 
06093     Tp::PendingVariantMap *requestAllProperties() const
06094     {
06095         return internalRequestAllProperties();
06096     }
06097 
06098 public Q_SLOTS:
06132     inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
06133     {
06134         if (!invalidationReason().isEmpty()) {
06135             return QDBusPendingReply<>(QDBusMessage::createError(
06136                 invalidationReason(),
06137                 invalidationMessage()
06138             ));
06139         }
06140 
06141         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06142                 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
06143         callMessage << QVariant::fromValue(activate);
06144         return this->connection().asyncCall(callMessage, timeout);
06145     }
06146 
06147 Q_SIGNALS:
06160     void PowerSavingChanged(bool active);
06161 
06162 protected:
06163     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06164 };
06165 
06173 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
06174 {
06175     Q_OBJECT
06176 
06177 public:
06184     static inline QLatin1String staticInterfaceName()
06185     {
06186         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
06187     }
06188 
06196     ConnectionInterfacePresenceInterface(
06197         const QString& busName,
06198         const QString& objectPath,
06199         QObject* parent = 0
06200     );
06201 
06210     ConnectionInterfacePresenceInterface(
06211         const QDBusConnection& connection,
06212         const QString& busName,
06213         const QString& objectPath,
06214         QObject* parent = 0
06215     );
06216 
06223     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
06224 
06232     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06233 
06241     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06242 
06249     Tp::PendingVariantMap *requestAllProperties() const
06250     {
06251         return internalRequestAllProperties();
06252     }
06253 
06254 public Q_SLOTS:
06276     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
06277     {
06278         if (!invalidationReason().isEmpty()) {
06279             return QDBusPendingReply<>(QDBusMessage::createError(
06280                 invalidationReason(),
06281                 invalidationMessage()
06282             ));
06283         }
06284 
06285         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06286                 this->staticInterfaceName(), QLatin1String("AddStatus"));
06287         callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
06288         return this->connection().asyncCall(callMessage, timeout);
06289     }
06290 
06304     inline QDBusPendingReply<> ClearStatus(int timeout = -1)
06305     {
06306         if (!invalidationReason().isEmpty()) {
06307             return QDBusPendingReply<>(QDBusMessage::createError(
06308                 invalidationReason(),
06309                 invalidationMessage()
06310             ));
06311         }
06312 
06313         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06314                 this->staticInterfaceName(), QLatin1String("ClearStatus"));
06315         return this->connection().asyncCall(callMessage, timeout);
06316     }
06317 
06341     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
06342     {
06343         if (!invalidationReason().isEmpty()) {
06344             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
06345                 invalidationReason(),
06346                 invalidationMessage()
06347             ));
06348         }
06349 
06350         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06351                 this->staticInterfaceName(), QLatin1String("GetPresence"));
06352         callMessage << QVariant::fromValue(contacts);
06353         return this->connection().asyncCall(callMessage, timeout);
06354     }
06355 
06377     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
06378     {
06379         if (!invalidationReason().isEmpty()) {
06380             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
06381                 invalidationReason(),
06382                 invalidationMessage()
06383             ));
06384         }
06385 
06386         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06387                 this->staticInterfaceName(), QLatin1String("GetStatuses"));
06388         return this->connection().asyncCall(callMessage, timeout);
06389     }
06390 
06409     inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
06410     {
06411         if (!invalidationReason().isEmpty()) {
06412             return QDBusPendingReply<>(QDBusMessage::createError(
06413                 invalidationReason(),
06414                 invalidationMessage()
06415             ));
06416         }
06417 
06418         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06419                 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
06420         callMessage << QVariant::fromValue(status);
06421         return this->connection().asyncCall(callMessage, timeout);
06422     }
06423 
06442     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
06443     {
06444         if (!invalidationReason().isEmpty()) {
06445             return QDBusPendingReply<>(QDBusMessage::createError(
06446                 invalidationReason(),
06447                 invalidationMessage()
06448             ));
06449         }
06450 
06451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06452                 this->staticInterfaceName(), QLatin1String("RequestPresence"));
06453         callMessage << QVariant::fromValue(contacts);
06454         return this->connection().asyncCall(callMessage, timeout);
06455     }
06456 
06472     inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
06473     {
06474         if (!invalidationReason().isEmpty()) {
06475             return QDBusPendingReply<>(QDBusMessage::createError(
06476                 invalidationReason(),
06477                 invalidationMessage()
06478             ));
06479         }
06480 
06481         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06482                 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
06483         callMessage << QVariant::fromValue(time);
06484         return this->connection().asyncCall(callMessage, timeout);
06485     }
06486 
06524     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
06525     {
06526         if (!invalidationReason().isEmpty()) {
06527             return QDBusPendingReply<>(QDBusMessage::createError(
06528                 invalidationReason(),
06529                 invalidationMessage()
06530             ));
06531         }
06532 
06533         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06534                 this->staticInterfaceName(), QLatin1String("SetStatus"));
06535         callMessage << QVariant::fromValue(statuses);
06536         return this->connection().asyncCall(callMessage, timeout);
06537     }
06538 
06539 Q_SIGNALS:
06556     void PresenceUpdate(const Tp::ContactPresences& presence);
06557 
06558 protected:
06559     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06560 };
06561 
06569 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
06570 {
06571     Q_OBJECT
06572 
06573 public:
06580     static inline QLatin1String staticInterfaceName()
06581     {
06582         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
06583     }
06584 
06592     ConnectionInterfaceRequestsInterface(
06593         const QString& busName,
06594         const QString& objectPath,
06595         QObject* parent = 0
06596     );
06597 
06606     ConnectionInterfaceRequestsInterface(
06607         const QDBusConnection& connection,
06608         const QString& busName,
06609         const QString& objectPath,
06610         QObject* parent = 0
06611     );
06612 
06619     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
06620 
06628     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
06629 
06637     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06638 
06649     inline Tp::PendingVariant *requestPropertyChannels() const
06650     {
06651         return internalRequestProperty(QLatin1String("Channels"));
06652     }
06653 
06683     inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
06684     {
06685         return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
06686     }
06687 
06694     Tp::PendingVariantMap *requestAllProperties() const
06695     {
06696         return internalRequestAllProperties();
06697     }
06698 
06699 public Q_SLOTS:
06781     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
06782     {
06783         if (!invalidationReason().isEmpty()) {
06784             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06785                 invalidationReason(),
06786                 invalidationMessage()
06787             ));
06788         }
06789 
06790         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06791                 this->staticInterfaceName(), QLatin1String("CreateChannel"));
06792         callMessage << QVariant::fromValue(request);
06793         return this->connection().asyncCall(callMessage, timeout);
06794     }
06795 
06860     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
06861     {
06862         if (!invalidationReason().isEmpty()) {
06863             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06864                 invalidationReason(),
06865                 invalidationMessage()
06866             ));
06867         }
06868 
06869         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06870                 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
06871         callMessage << QVariant::fromValue(request);
06872         return this->connection().asyncCall(callMessage, timeout);
06873     }
06874 
06875 Q_SIGNALS:
06919     void NewChannels(const Tp::ChannelDetailsList& channels);
06920 
06933     void ChannelClosed(const QDBusObjectPath& removed);
06934 
06935 protected:
06936     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06937 };
06938 
06946 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
06947 {
06948     Q_OBJECT
06949 
06950 public:
06957     static inline QLatin1String staticInterfaceName()
06958     {
06959         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
06960     }
06961 
06969     ConnectionInterfaceServicePointInterface(
06970         const QString& busName,
06971         const QString& objectPath,
06972         QObject* parent = 0
06973     );
06974 
06983     ConnectionInterfaceServicePointInterface(
06984         const QDBusConnection& connection,
06985         const QString& busName,
06986         const QString& objectPath,
06987         QObject* parent = 0
06988     );
06989 
06996     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
06997 
07005     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
07006 
07014     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07015 
07027     inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
07028     {
07029         return internalRequestProperty(QLatin1String("KnownServicePoints"));
07030     }
07031 
07038     Tp::PendingVariantMap *requestAllProperties() const
07039     {
07040         return internalRequestAllProperties();
07041     }
07042 
07043 Q_SIGNALS:
07057     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
07058 
07059 protected:
07060     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07061 };
07062 
07070 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
07071 {
07072     Q_OBJECT
07073 
07074 public:
07081     static inline QLatin1String staticInterfaceName()
07082     {
07083         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
07084     }
07085 
07093     ConnectionInterfaceSimplePresenceInterface(
07094         const QString& busName,
07095         const QString& objectPath,
07096         QObject* parent = 0
07097     );
07098 
07107     ConnectionInterfaceSimplePresenceInterface(
07108         const QDBusConnection& connection,
07109         const QString& busName,
07110         const QString& objectPath,
07111         QObject* parent = 0
07112     );
07113 
07120     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
07121 
07129     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
07130 
07138     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07139 
07181     inline Tp::PendingVariant *requestPropertyStatuses() const
07182     {
07183         return internalRequestProperty(QLatin1String("Statuses"));
07184     }
07185 
07192     Tp::PendingVariantMap *requestAllProperties() const
07193     {
07194         return internalRequestAllProperties();
07195     }
07196 
07197 public Q_SLOTS:
07261     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
07262     {
07263         if (!invalidationReason().isEmpty()) {
07264             return QDBusPendingReply<>(QDBusMessage::createError(
07265                 invalidationReason(),
07266                 invalidationMessage()
07267             ));
07268         }
07269 
07270         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07271                 this->staticInterfaceName(), QLatin1String("SetPresence"));
07272         callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
07273         return this->connection().asyncCall(callMessage, timeout);
07274     }
07275 
07307     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
07308     {
07309         if (!invalidationReason().isEmpty()) {
07310             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
07311                 invalidationReason(),
07312                 invalidationMessage()
07313             ));
07314         }
07315 
07316         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07317                 this->staticInterfaceName(), QLatin1String("GetPresences"));
07318         callMessage << QVariant::fromValue(contacts);
07319         return this->connection().asyncCall(callMessage, timeout);
07320     }
07321 
07322 Q_SIGNALS:
07335     void PresencesChanged(const Tp::SimpleContactPresences& presence);
07336 
07337 protected:
07338     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07339 };
07340 }
07341 }
07342 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
07343 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
07344 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
07345 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
07346 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
07347 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
07348 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
07349 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
07350 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
07351 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
07352 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
07353 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
07354 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
07355 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
07356 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
07357 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
07358 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
07359 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
07360 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
07361 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
07362 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)

Copyright © 2008-2011 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.6.5