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 
00125     inline Tp::PendingVariant *requestPropertyInterfaces() const
00126     {
00127         return internalRequestProperty(QLatin1String("Interfaces"));
00128     }
00129 
00143     inline Tp::PendingVariant *requestPropertySelfHandle() const
00144     {
00145         return internalRequestProperty(QLatin1String("SelfHandle"));
00146     }
00147 
00164     inline Tp::PendingVariant *requestPropertyStatus() const
00165     {
00166         return internalRequestProperty(QLatin1String("Status"));
00167     }
00168 
00175     Tp::PendingVariantMap *requestAllProperties() const
00176     {
00177         return internalRequestAllProperties();
00178     }
00179 
00180 public Q_SLOTS:
00196     inline QDBusPendingReply<> Connect(int timeout = -1)
00197     {
00198         if (!invalidationReason().isEmpty()) {
00199             return QDBusPendingReply<>(QDBusMessage::createError(
00200                 invalidationReason(),
00201                 invalidationMessage()
00202             ));
00203         }
00204 
00205         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00206                 this->staticInterfaceName(), QLatin1String("Connect"));
00207         return this->connection().asyncCall(callMessage, timeout);
00208     }
00209 
00222     inline QDBusPendingReply<> Disconnect(int timeout = -1)
00223     {
00224         if (!invalidationReason().isEmpty()) {
00225             return QDBusPendingReply<>(QDBusMessage::createError(
00226                 invalidationReason(),
00227                 invalidationMessage()
00228             ));
00229         }
00230 
00231         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00232                 this->staticInterfaceName(), QLatin1String("Disconnect"));
00233         return this->connection().asyncCall(callMessage, timeout);
00234     }
00235 
00252     inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00253     {
00254         if (!invalidationReason().isEmpty()) {
00255             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00256                 invalidationReason(),
00257                 invalidationMessage()
00258             ));
00259         }
00260 
00261         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00262                 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00263         return this->connection().asyncCall(callMessage, timeout);
00264     }
00265 
00280     inline QDBusPendingReply<QString> GetProtocol(int timeout = -1)
00281     {
00282         if (!invalidationReason().isEmpty()) {
00283             return QDBusPendingReply<QString>(QDBusMessage::createError(
00284                 invalidationReason(),
00285                 invalidationMessage()
00286             ));
00287         }
00288 
00289         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00290                 this->staticInterfaceName(), QLatin1String("GetProtocol"));
00291         return this->connection().asyncCall(callMessage, timeout);
00292     }
00293 
00309     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
00310     {
00311         if (!invalidationReason().isEmpty()) {
00312             return QDBusPendingReply<uint>(QDBusMessage::createError(
00313                 invalidationReason(),
00314                 invalidationMessage()
00315             ));
00316         }
00317 
00318         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00319                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
00320         return this->connection().asyncCall(callMessage, timeout);
00321     }
00322 
00337     inline QDBusPendingReply<uint> GetStatus(int timeout = -1)
00338     {
00339         if (!invalidationReason().isEmpty()) {
00340             return QDBusPendingReply<uint>(QDBusMessage::createError(
00341                 invalidationReason(),
00342                 invalidationMessage()
00343             ));
00344         }
00345 
00346         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00347                 this->staticInterfaceName(), QLatin1String("GetStatus"));
00348         return this->connection().asyncCall(callMessage, timeout);
00349     }
00350 
00385     inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00386     {
00387         if (!invalidationReason().isEmpty()) {
00388             return QDBusPendingReply<>(QDBusMessage::createError(
00389                 invalidationReason(),
00390                 invalidationMessage()
00391             ));
00392         }
00393 
00394         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00395                 this->staticInterfaceName(), QLatin1String("HoldHandles"));
00396         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00397         return this->connection().asyncCall(callMessage, timeout);
00398     }
00399 
00423     inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00424     {
00425         if (!invalidationReason().isEmpty()) {
00426             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00427                 invalidationReason(),
00428                 invalidationMessage()
00429             ));
00430         }
00431 
00432         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00433                 this->staticInterfaceName(), QLatin1String("InspectHandles"));
00434         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00435         return this->connection().asyncCall(callMessage, timeout);
00436     }
00437 
00452     inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels(int timeout = -1)
00453     {
00454         if (!invalidationReason().isEmpty()) {
00455             return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00456                 invalidationReason(),
00457                 invalidationMessage()
00458             ));
00459         }
00460 
00461         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00462                 this->staticInterfaceName(), QLatin1String("ListChannels"));
00463         return this->connection().asyncCall(callMessage, timeout);
00464     }
00465 
00487     inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00488     {
00489         if (!invalidationReason().isEmpty()) {
00490             return QDBusPendingReply<>(QDBusMessage::createError(
00491                 invalidationReason(),
00492                 invalidationMessage()
00493             ));
00494         }
00495 
00496         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00497                 this->staticInterfaceName(), QLatin1String("ReleaseHandles"));
00498         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00499         return this->connection().asyncCall(callMessage, timeout);
00500     }
00501 
00579     inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler, int timeout = -1)
00580     {
00581         if (!invalidationReason().isEmpty()) {
00582             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00583                 invalidationReason(),
00584                 invalidationMessage()
00585             ));
00586         }
00587 
00588         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00589                 this->staticInterfaceName(), QLatin1String("RequestChannel"));
00590         callMessage << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00591         return this->connection().asyncCall(callMessage, timeout);
00592     }
00593 
00625     inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers, int timeout = -1)
00626     {
00627         if (!invalidationReason().isEmpty()) {
00628             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00629                 invalidationReason(),
00630                 invalidationMessage()
00631             ));
00632         }
00633 
00634         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00635                 this->staticInterfaceName(), QLatin1String("RequestHandles"));
00636         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
00637         return this->connection().asyncCall(callMessage, timeout);
00638     }
00639 
00640 Q_SIGNALS:
00652     void SelfHandleChanged(uint selfHandle);
00653 
00695     void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00696 
00756     void ConnectionError(const QString& error, const QVariantMap& details);
00757 
00774     void StatusChanged(uint status, uint reason);
00775 
00776 protected:
00777     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00778 };
00779 
00787 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00788 {
00789     Q_OBJECT
00790 
00791 public:
00798     static inline QLatin1String staticInterfaceName()
00799     {
00800         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
00801     }
00802 
00810     ConnectionInterfaceAliasingInterface(
00811         const QString& busName,
00812         const QString& objectPath,
00813         QObject* parent = 0
00814     );
00815 
00824     ConnectionInterfaceAliasingInterface(
00825         const QDBusConnection& connection,
00826         const QString& busName,
00827         const QString& objectPath,
00828         QObject* parent = 0
00829     );
00830 
00837     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
00838 
00846     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
00847 
00855     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
00856 
00863     Tp::PendingVariantMap *requestAllProperties() const
00864     {
00865         return internalRequestAllProperties();
00866     }
00867 
00868 public Q_SLOTS:
00884     inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
00885     {
00886         if (!invalidationReason().isEmpty()) {
00887             return QDBusPendingReply<uint>(QDBusMessage::createError(
00888                 invalidationReason(),
00889                 invalidationMessage()
00890             ));
00891         }
00892 
00893         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00894                 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
00895         return this->connection().asyncCall(callMessage, timeout);
00896     }
00897 
00916     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
00917     {
00918         if (!invalidationReason().isEmpty()) {
00919             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00920                 invalidationReason(),
00921                 invalidationMessage()
00922             ));
00923         }
00924 
00925         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00926                 this->staticInterfaceName(), QLatin1String("RequestAliases"));
00927         callMessage << QVariant::fromValue(contacts);
00928         return this->connection().asyncCall(callMessage, timeout);
00929     }
00930 
00953     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
00954     {
00955         if (!invalidationReason().isEmpty()) {
00956             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
00957                 invalidationReason(),
00958                 invalidationMessage()
00959             ));
00960         }
00961 
00962         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00963                 this->staticInterfaceName(), QLatin1String("GetAliases"));
00964         callMessage << QVariant::fromValue(contacts);
00965         return this->connection().asyncCall(callMessage, timeout);
00966     }
00967 
00987     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
00988     {
00989         if (!invalidationReason().isEmpty()) {
00990             return QDBusPendingReply<>(QDBusMessage::createError(
00991                 invalidationReason(),
00992                 invalidationMessage()
00993             ));
00994         }
00995 
00996         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00997                 this->staticInterfaceName(), QLatin1String("SetAliases"));
00998         callMessage << QVariant::fromValue(aliases);
00999         return this->connection().asyncCall(callMessage, timeout);
01000     }
01001 
01002 Q_SIGNALS:
01017     void AliasesChanged(const Tp::AliasPairList& aliases);
01018 
01019 protected:
01020     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01021 };
01022 
01030 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
01031 {
01032     Q_OBJECT
01033 
01034 public:
01041     static inline QLatin1String staticInterfaceName()
01042     {
01043         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
01044     }
01045 
01053     ConnectionInterfaceAnonymityInterface(
01054         const QString& busName,
01055         const QString& objectPath,
01056         QObject* parent = 0
01057     );
01058 
01067     ConnectionInterfaceAnonymityInterface(
01068         const QDBusConnection& connection,
01069         const QString& busName,
01070         const QString& objectPath,
01071         QObject* parent = 0
01072     );
01073 
01080     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
01081 
01089     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01090 
01098     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01099 
01110     inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
01111     {
01112         return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
01113     }
01114 
01137     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
01138     {
01139         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
01140     }
01141 
01164     inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
01165     {
01166         return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
01167     }
01168 
01188     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
01189     {
01190         return internalRequestProperty(QLatin1String("AnonymityModes"));
01191     }
01192 
01212     inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
01213     {
01214         return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
01215     }
01216 
01223     Tp::PendingVariantMap *requestAllProperties() const
01224     {
01225         return internalRequestAllProperties();
01226     }
01227 
01228 Q_SIGNALS:
01238     void AnonymityModesChanged(uint modes);
01239 
01240 protected:
01241     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01242 };
01243 
01251 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01252 {
01253     Q_OBJECT
01254 
01255 public:
01262     static inline QLatin1String staticInterfaceName()
01263     {
01264         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
01265     }
01266 
01274     ConnectionInterfaceAvatarsInterface(
01275         const QString& busName,
01276         const QString& objectPath,
01277         QObject* parent = 0
01278     );
01279 
01288     ConnectionInterfaceAvatarsInterface(
01289         const QDBusConnection& connection,
01290         const QString& busName,
01291         const QString& objectPath,
01292         QObject* parent = 0
01293     );
01294 
01301     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01302 
01310     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01311 
01319     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01320 
01332     inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
01333     {
01334         return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
01335     }
01336 
01348     inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
01349     {
01350         return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
01351     }
01352 
01364     inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
01365     {
01366         return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
01367     }
01368 
01383     inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
01384     {
01385         return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
01386     }
01387 
01400     inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
01401     {
01402         return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
01403     }
01404 
01416     inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
01417     {
01418         return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
01419     }
01420 
01432     inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
01433     {
01434         return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
01435     }
01436 
01448     inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
01449     {
01450         return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
01451     }
01452 
01459     Tp::PendingVariantMap *requestAllProperties() const
01460     {
01461         return internalRequestAllProperties();
01462     }
01463 
01464 public Q_SLOTS:
01499     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
01500     {
01501         if (!invalidationReason().isEmpty()) {
01502             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01503                 invalidationReason(),
01504                 invalidationMessage()
01505             ));
01506         }
01507 
01508         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01509                 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
01510         return this->connection().asyncCall(callMessage, timeout);
01511     }
01512 
01534     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01535     {
01536         if (!invalidationReason().isEmpty()) {
01537             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01538                 invalidationReason(),
01539                 invalidationMessage()
01540             ));
01541         }
01542 
01543         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01544                 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
01545         callMessage << QVariant::fromValue(contacts);
01546         return this->connection().asyncCall(callMessage, timeout);
01547     }
01548 
01576     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01577     {
01578         if (!invalidationReason().isEmpty()) {
01579             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01580                 invalidationReason(),
01581                 invalidationMessage()
01582             ));
01583         }
01584 
01585         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01586                 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
01587         callMessage << QVariant::fromValue(contacts);
01588         return this->connection().asyncCall(callMessage, timeout);
01589     }
01590 
01615     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
01616     {
01617         if (!invalidationReason().isEmpty()) {
01618             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01619                 invalidationReason(),
01620                 invalidationMessage()
01621             ));
01622         }
01623 
01624         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01625                 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
01626         callMessage << QVariant::fromValue(contact);
01627         return this->connection().asyncCall(callMessage, timeout);
01628     }
01629 
01648     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
01649     {
01650         if (!invalidationReason().isEmpty()) {
01651             return QDBusPendingReply<>(QDBusMessage::createError(
01652                 invalidationReason(),
01653                 invalidationMessage()
01654             ));
01655         }
01656 
01657         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01658                 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
01659         callMessage << QVariant::fromValue(contacts);
01660         return this->connection().asyncCall(callMessage, timeout);
01661     }
01662 
01686     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
01687     {
01688         if (!invalidationReason().isEmpty()) {
01689             return QDBusPendingReply<QString>(QDBusMessage::createError(
01690                 invalidationReason(),
01691                 invalidationMessage()
01692             ));
01693         }
01694 
01695         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01696                 this->staticInterfaceName(), QLatin1String("SetAvatar"));
01697         callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01698         return this->connection().asyncCall(callMessage, timeout);
01699     }
01700 
01711     inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
01712     {
01713         if (!invalidationReason().isEmpty()) {
01714             return QDBusPendingReply<>(QDBusMessage::createError(
01715                 invalidationReason(),
01716                 invalidationMessage()
01717             ));
01718         }
01719 
01720         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01721                 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
01722         return this->connection().asyncCall(callMessage, timeout);
01723     }
01724 
01725 Q_SIGNALS:
01742     void AvatarUpdated(uint contact, const QString& newAvatarToken);
01743 
01766     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01767 
01768 protected:
01769     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01770 };
01771 
01779 class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01780 {
01781     Q_OBJECT
01782 
01783 public:
01790     static inline QLatin1String staticInterfaceName()
01791     {
01792         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
01793     }
01794 
01802     ConnectionInterfaceBalanceInterface(
01803         const QString& busName,
01804         const QString& objectPath,
01805         QObject* parent = 0
01806     );
01807 
01816     ConnectionInterfaceBalanceInterface(
01817         const QDBusConnection& connection,
01818         const QString& busName,
01819         const QString& objectPath,
01820         QObject* parent = 0
01821     );
01822 
01829     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
01830 
01838     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01839 
01847     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01848 
01865     inline Tp::PendingVariant *requestPropertyAccountBalance() const
01866     {
01867         return internalRequestProperty(QLatin1String("AccountBalance"));
01868     }
01869 
01876     Tp::PendingVariantMap *requestAllProperties() const
01877     {
01878         return internalRequestAllProperties();
01879     }
01880 
01881 Q_SIGNALS:
01892     void BalanceChanged(const Tp::CurrencyAmount& balance);
01893 
01894 protected:
01895     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01896 };
01897 
01905 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
01906 {
01907     Q_OBJECT
01908 
01909 public:
01916     static inline QLatin1String staticInterfaceName()
01917     {
01918         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
01919     }
01920 
01928     ConnectionInterfaceCapabilitiesInterface(
01929         const QString& busName,
01930         const QString& objectPath,
01931         QObject* parent = 0
01932     );
01933 
01942     ConnectionInterfaceCapabilitiesInterface(
01943         const QDBusConnection& connection,
01944         const QString& busName,
01945         const QString& objectPath,
01946         QObject* parent = 0
01947     );
01948 
01955     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
01956 
01964     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
01965 
01973     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01974 
01981     Tp::PendingVariantMap *requestAllProperties() const
01982     {
01983         return internalRequestAllProperties();
01984     }
01985 
01986 public Q_SLOTS:
02036     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
02037     {
02038         if (!invalidationReason().isEmpty()) {
02039             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
02040                 invalidationReason(),
02041                 invalidationMessage()
02042             ));
02043         }
02044 
02045         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02046                 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
02047         callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
02048         return this->connection().asyncCall(callMessage, timeout);
02049     }
02050 
02081     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
02082     {
02083         if (!invalidationReason().isEmpty()) {
02084             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
02085                 invalidationReason(),
02086                 invalidationMessage()
02087             ));
02088         }
02089 
02090         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02091                 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
02092         callMessage << QVariant::fromValue(handles);
02093         return this->connection().asyncCall(callMessage, timeout);
02094     }
02095 
02096 Q_SIGNALS:
02119     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
02120 
02121 protected:
02122     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02123 };
02124 
02132 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
02133 {
02134     Q_OBJECT
02135 
02136 public:
02143     static inline QLatin1String staticInterfaceName()
02144     {
02145         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
02146     }
02147 
02155     ConnectionInterfaceCellularInterface(
02156         const QString& busName,
02157         const QString& objectPath,
02158         QObject* parent = 0
02159     );
02160 
02169     ConnectionInterfaceCellularInterface(
02170         const QDBusConnection& connection,
02171         const QString& busName,
02172         const QString& objectPath,
02173         QObject* parent = 0
02174     );
02175 
02182     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02183 
02191     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02192 
02200     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02201 
02234     inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
02235     {
02236         return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
02237     }
02238 
02271     inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
02272     {
02273         return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
02274     }
02275 
02312     inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
02313     {
02314         return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
02315     }
02316 
02353     inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
02354     {
02355         return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
02356     }
02357 
02388     inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
02389     {
02390         return internalRequestProperty(QLatin1String("MessageServiceCentre"));
02391     }
02392 
02423     inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
02424     {
02425         return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
02426     }
02427 
02439     inline Tp::PendingVariant *requestPropertyIMSI() const
02440     {
02441         return internalRequestProperty(QLatin1String("IMSI"));
02442     }
02443 
02475     inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
02476     {
02477         return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
02478     }
02479 
02511     inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
02512     {
02513         return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
02514     }
02515 
02522     Tp::PendingVariantMap *requestAllProperties() const
02523     {
02524         return internalRequestAllProperties();
02525     }
02526 
02527 Q_SIGNALS:
02543     void IMSIChanged(const QString& IMSI);
02544 
02545 protected:
02546     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02547 };
02548 
02556 class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
02557 {
02558     Q_OBJECT
02559 
02560 public:
02567     static inline QLatin1String staticInterfaceName()
02568     {
02569         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
02570     }
02571 
02579     ConnectionInterfaceClientTypesInterface(
02580         const QString& busName,
02581         const QString& objectPath,
02582         QObject* parent = 0
02583     );
02584 
02593     ConnectionInterfaceClientTypesInterface(
02594         const QDBusConnection& connection,
02595         const QString& busName,
02596         const QString& objectPath,
02597         QObject* parent = 0
02598     );
02599 
02606     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
02607 
02615     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02616 
02624     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02625 
02632     Tp::PendingVariantMap *requestAllProperties() const
02633     {
02634         return internalRequestAllProperties();
02635     }
02636 
02637 public Q_SLOTS:
02666     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
02667     {
02668         if (!invalidationReason().isEmpty()) {
02669             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
02670                 invalidationReason(),
02671                 invalidationMessage()
02672             ));
02673         }
02674 
02675         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02676                 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
02677         callMessage << QVariant::fromValue(contacts);
02678         return this->connection().asyncCall(callMessage, timeout);
02679     }
02680 
02705     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
02706     {
02707         if (!invalidationReason().isEmpty()) {
02708             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02709                 invalidationReason(),
02710                 invalidationMessage()
02711             ));
02712         }
02713 
02714         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02715                 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
02716         callMessage << QVariant::fromValue(contact);
02717         return this->connection().asyncCall(callMessage, timeout);
02718     }
02719 
02720 Q_SIGNALS:
02735     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
02736 
02737 protected:
02738     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02739 };
02740 
02748 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
02749 {
02750     Q_OBJECT
02751 
02752 public:
02759     static inline QLatin1String staticInterfaceName()
02760     {
02761         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
02762     }
02763 
02771     ConnectionInterfaceContactCapabilitiesInterface(
02772         const QString& busName,
02773         const QString& objectPath,
02774         QObject* parent = 0
02775     );
02776 
02785     ConnectionInterfaceContactCapabilitiesInterface(
02786         const QDBusConnection& connection,
02787         const QString& busName,
02788         const QString& objectPath,
02789         QObject* parent = 0
02790     );
02791 
02798     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
02799 
02807     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02808 
02816     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02817 
02824     Tp::PendingVariantMap *requestAllProperties() const
02825     {
02826         return internalRequestAllProperties();
02827     }
02828 
02829 public Q_SLOTS:
02890     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
02891     {
02892         if (!invalidationReason().isEmpty()) {
02893             return QDBusPendingReply<>(QDBusMessage::createError(
02894                 invalidationReason(),
02895                 invalidationMessage()
02896             ));
02897         }
02898 
02899         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02900                 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
02901         callMessage << QVariant::fromValue(handlerCapabilities);
02902         return this->connection().asyncCall(callMessage, timeout);
02903     }
02904 
02934     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
02935     {
02936         if (!invalidationReason().isEmpty()) {
02937             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
02938                 invalidationReason(),
02939                 invalidationMessage()
02940             ));
02941         }
02942 
02943         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02944                 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
02945         callMessage << QVariant::fromValue(handles);
02946         return this->connection().asyncCall(callMessage, timeout);
02947     }
02948 
02949 Q_SIGNALS:
02966     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
02967 
02968 protected:
02969     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02970 };
02971 
02979 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
02980 {
02981     Q_OBJECT
02982 
02983 public:
02990     static inline QLatin1String staticInterfaceName()
02991     {
02992         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
02993     }
02994 
03002     ConnectionInterfaceContactGroupsInterface(
03003         const QString& busName,
03004         const QString& objectPath,
03005         QObject* parent = 0
03006     );
03007 
03016     ConnectionInterfaceContactGroupsInterface(
03017         const QDBusConnection& connection,
03018         const QString& busName,
03019         const QString& objectPath,
03020         QObject* parent = 0
03021     );
03022 
03029     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
03030 
03038     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03039 
03047     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03048 
03063     inline Tp::PendingVariant *requestPropertyDisjointGroups() const
03064     {
03065         return internalRequestProperty(QLatin1String("DisjointGroups"));
03066     }
03067 
03080     inline Tp::PendingVariant *requestPropertyGroupStorage() const
03081     {
03082         return internalRequestProperty(QLatin1String("GroupStorage"));
03083     }
03084 
03106     inline Tp::PendingVariant *requestPropertyGroups() const
03107     {
03108         return internalRequestProperty(QLatin1String("Groups"));
03109     }
03110 
03117     Tp::PendingVariantMap *requestAllProperties() const
03118     {
03119         return internalRequestAllProperties();
03120     }
03121 
03122 public Q_SLOTS:
03169     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
03170     {
03171         if (!invalidationReason().isEmpty()) {
03172             return QDBusPendingReply<>(QDBusMessage::createError(
03173                 invalidationReason(),
03174                 invalidationMessage()
03175             ));
03176         }
03177 
03178         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03179                 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
03180         callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
03181         return this->connection().asyncCall(callMessage, timeout);
03182     }
03183 
03229     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
03230     {
03231         if (!invalidationReason().isEmpty()) {
03232             return QDBusPendingReply<>(QDBusMessage::createError(
03233                 invalidationReason(),
03234                 invalidationMessage()
03235             ));
03236         }
03237 
03238         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03239                 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
03240         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03241         return this->connection().asyncCall(callMessage, timeout);
03242     }
03243 
03282     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03283     {
03284         if (!invalidationReason().isEmpty()) {
03285             return QDBusPendingReply<>(QDBusMessage::createError(
03286                 invalidationReason(),
03287                 invalidationMessage()
03288             ));
03289         }
03290 
03291         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03292                 this->staticInterfaceName(), QLatin1String("AddToGroup"));
03293         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03294         return this->connection().asyncCall(callMessage, timeout);
03295     }
03296 
03334     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03335     {
03336         if (!invalidationReason().isEmpty()) {
03337             return QDBusPendingReply<>(QDBusMessage::createError(
03338                 invalidationReason(),
03339                 invalidationMessage()
03340             ));
03341         }
03342 
03343         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03344                 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
03345         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03346         return this->connection().asyncCall(callMessage, timeout);
03347     }
03348 
03375     inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
03376     {
03377         if (!invalidationReason().isEmpty()) {
03378             return QDBusPendingReply<>(QDBusMessage::createError(
03379                 invalidationReason(),
03380                 invalidationMessage()
03381             ));
03382         }
03383 
03384         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03385                 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
03386         callMessage << QVariant::fromValue(group);
03387         return this->connection().asyncCall(callMessage, timeout);
03388     }
03389 
03427     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
03428     {
03429         if (!invalidationReason().isEmpty()) {
03430             return QDBusPendingReply<>(QDBusMessage::createError(
03431                 invalidationReason(),
03432                 invalidationMessage()
03433             ));
03434         }
03435 
03436         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03437                 this->staticInterfaceName(), QLatin1String("RenameGroup"));
03438         callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
03439         return this->connection().asyncCall(callMessage, timeout);
03440     }
03441 
03442 Q_SIGNALS:
03460     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
03461 
03472     void GroupsCreated(const QStringList& names);
03473 
03519     void GroupRenamed(const QString& oldName, const QString& newName);
03520 
03545     void GroupsRemoved(const QStringList& names);
03546 
03547 protected:
03548     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03549 };
03550 
03558 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
03559 {
03560     Q_OBJECT
03561 
03562 public:
03569     static inline QLatin1String staticInterfaceName()
03570     {
03571         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
03572     }
03573 
03581     ConnectionInterfaceContactInfoInterface(
03582         const QString& busName,
03583         const QString& objectPath,
03584         QObject* parent = 0
03585     );
03586 
03595     ConnectionInterfaceContactInfoInterface(
03596         const QDBusConnection& connection,
03597         const QString& busName,
03598         const QString& objectPath,
03599         QObject* parent = 0
03600     );
03601 
03608     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
03609 
03617     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
03618 
03626     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03627 
03649     inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
03650     {
03651         return internalRequestProperty(QLatin1String("ContactInfoFlags"));
03652     }
03653 
03709     inline Tp::PendingVariant *requestPropertySupportedFields() const
03710     {
03711         return internalRequestProperty(QLatin1String("SupportedFields"));
03712     }
03713 
03720     Tp::PendingVariantMap *requestAllProperties() const
03721     {
03722         return internalRequestAllProperties();
03723     }
03724 
03725 public Q_SLOTS:
03748     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
03749     {
03750         if (!invalidationReason().isEmpty()) {
03751             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
03752                 invalidationReason(),
03753                 invalidationMessage()
03754             ));
03755         }
03756 
03757         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03758                 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
03759         callMessage << QVariant::fromValue(contacts);
03760         return this->connection().asyncCall(callMessage, timeout);
03761     }
03762 
03782     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
03783     {
03784         if (!invalidationReason().isEmpty()) {
03785             return QDBusPendingReply<>(QDBusMessage::createError(
03786                 invalidationReason(),
03787                 invalidationMessage()
03788             ));
03789         }
03790 
03791         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03792                 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
03793         callMessage << QVariant::fromValue(contacts);
03794         return this->connection().asyncCall(callMessage, timeout);
03795     }
03796 
03818     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
03819     {
03820         if (!invalidationReason().isEmpty()) {
03821             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
03822                 invalidationReason(),
03823                 invalidationMessage()
03824             ));
03825         }
03826 
03827         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03828                 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
03829         callMessage << QVariant::fromValue(contact);
03830         return this->connection().asyncCall(callMessage, timeout);
03831     }
03832 
03850     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
03851     {
03852         if (!invalidationReason().isEmpty()) {
03853             return QDBusPendingReply<>(QDBusMessage::createError(
03854                 invalidationReason(),
03855                 invalidationMessage()
03856             ));
03857         }
03858 
03859         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03860                 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
03861         callMessage << QVariant::fromValue(contactInfo);
03862         return this->connection().asyncCall(callMessage, timeout);
03863     }
03864 
03865 Q_SIGNALS:
03880     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
03881 
03882 protected:
03883     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03884 };
03885 
03893 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
03894 {
03895     Q_OBJECT
03896 
03897 public:
03904     static inline QLatin1String staticInterfaceName()
03905     {
03906         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
03907     }
03908 
03916     ConnectionInterfaceContactListInterface(
03917         const QString& busName,
03918         const QString& objectPath,
03919         QObject* parent = 0
03920     );
03921 
03930     ConnectionInterfaceContactListInterface(
03931         const QDBusConnection& connection,
03932         const QString& busName,
03933         const QString& objectPath,
03934         QObject* parent = 0
03935     );
03936 
03943     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
03944 
03952     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
03953 
03961     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03962 
03973     inline Tp::PendingVariant *requestPropertyContactListState() const
03974     {
03975         return internalRequestProperty(QLatin1String("ContactListState"));
03976     }
03977 
04035     inline Tp::PendingVariant *requestPropertyContactListPersists() const
04036     {
04037         return internalRequestProperty(QLatin1String("ContactListPersists"));
04038     }
04039 
04066     inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
04067     {
04068         return internalRequestProperty(QLatin1String("CanChangeContactList"));
04069     }
04070 
04097     inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
04098     {
04099         return internalRequestProperty(QLatin1String("RequestUsesMessage"));
04100     }
04101 
04108     Tp::PendingVariantMap *requestAllProperties() const
04109     {
04110         return internalRequestAllProperties();
04111     }
04112 
04113 public Q_SLOTS:
04174     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
04175     {
04176         if (!invalidationReason().isEmpty()) {
04177             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04178                 invalidationReason(),
04179                 invalidationMessage()
04180             ));
04181         }
04182 
04183         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04184                 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
04185         callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04186         return this->connection().asyncCall(callMessage, timeout);
04187     }
04188 
04281     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
04282     {
04283         if (!invalidationReason().isEmpty()) {
04284             return QDBusPendingReply<>(QDBusMessage::createError(
04285                 invalidationReason(),
04286                 invalidationMessage()
04287             ));
04288         }
04289 
04290         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04291                 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
04292         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
04293         return this->connection().asyncCall(callMessage, timeout);
04294     }
04295 
04350     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
04351     {
04352         if (!invalidationReason().isEmpty()) {
04353             return QDBusPendingReply<>(QDBusMessage::createError(
04354                 invalidationReason(),
04355                 invalidationMessage()
04356             ));
04357         }
04358 
04359         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04360                 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
04361         callMessage << QVariant::fromValue(contacts);
04362         return this->connection().asyncCall(callMessage, timeout);
04363     }
04364 
04410     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
04411     {
04412         if (!invalidationReason().isEmpty()) {
04413             return QDBusPendingReply<>(QDBusMessage::createError(
04414                 invalidationReason(),
04415                 invalidationMessage()
04416             ));
04417         }
04418 
04419         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04420                 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
04421         callMessage << QVariant::fromValue(contacts);
04422         return this->connection().asyncCall(callMessage, timeout);
04423     }
04424 
04457     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
04458     {
04459         if (!invalidationReason().isEmpty()) {
04460             return QDBusPendingReply<>(QDBusMessage::createError(
04461                 invalidationReason(),
04462                 invalidationMessage()
04463             ));
04464         }
04465 
04466         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04467                 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
04468         callMessage << QVariant::fromValue(contacts);
04469         return this->connection().asyncCall(callMessage, timeout);
04470     }
04471 
04504     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
04505     {
04506         if (!invalidationReason().isEmpty()) {
04507             return QDBusPendingReply<>(QDBusMessage::createError(
04508                 invalidationReason(),
04509                 invalidationMessage()
04510             ));
04511         }
04512 
04513         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04514                 this->staticInterfaceName(), QLatin1String("Unpublish"));
04515         callMessage << QVariant::fromValue(contacts);
04516         return this->connection().asyncCall(callMessage, timeout);
04517     }
04518 
04519 Q_SIGNALS:
04529     void ContactListStateChanged(uint contactListState);
04530 
04570     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
04571 
04572 protected:
04573     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04574 };
04575 
04583 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
04584 {
04585     Q_OBJECT
04586 
04587 public:
04594     static inline QLatin1String staticInterfaceName()
04595     {
04596         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
04597     }
04598 
04606     ConnectionInterfaceContactsInterface(
04607         const QString& busName,
04608         const QString& objectPath,
04609         QObject* parent = 0
04610     );
04611 
04620     ConnectionInterfaceContactsInterface(
04621         const QDBusConnection& connection,
04622         const QString& busName,
04623         const QString& objectPath,
04624         QObject* parent = 0
04625     );
04626 
04633     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
04634 
04642     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
04643 
04651     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04652 
04663     inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
04664     {
04665         return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
04666     }
04667 
04674     Tp::PendingVariantMap *requestAllProperties() const
04675     {
04676         return internalRequestAllProperties();
04677     }
04678 
04679 public Q_SLOTS:
04750     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
04751     {
04752         if (!invalidationReason().isEmpty()) {
04753             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04754                 invalidationReason(),
04755                 invalidationMessage()
04756             ));
04757         }
04758 
04759         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04760                 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
04761         callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04762         return this->connection().asyncCall(callMessage, timeout);
04763     }
04764 
04765 protected:
04766     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04767 };
04768 
04776 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
04777 {
04778     Q_OBJECT
04779 
04780 public:
04787     static inline QLatin1String staticInterfaceName()
04788     {
04789         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
04790     }
04791 
04799     ConnectionInterfaceLocationInterface(
04800         const QString& busName,
04801         const QString& objectPath,
04802         QObject* parent = 0
04803     );
04804 
04813     ConnectionInterfaceLocationInterface(
04814         const QDBusConnection& connection,
04815         const QString& busName,
04816         const QString& objectPath,
04817         QObject* parent = 0
04818     );
04819 
04826     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
04827 
04835     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
04836 
04844     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04845 
04855     inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
04856     {
04857         return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
04858     }
04859 
04872     inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
04873     {
04874         return internalRequestProperty(QLatin1String("LocationAccessControl"));
04875     }
04876 
04889     inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
04890     {
04891         return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
04892     }
04893 
04905     inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
04906     {
04907         return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
04908     }
04909 
04916     Tp::PendingVariantMap *requestAllProperties() const
04917     {
04918         return internalRequestAllProperties();
04919     }
04920 
04921 public Q_SLOTS:
04950     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
04951     {
04952         if (!invalidationReason().isEmpty()) {
04953             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
04954                 invalidationReason(),
04955                 invalidationMessage()
04956             ));
04957         }
04958 
04959         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04960                 this->staticInterfaceName(), QLatin1String("GetLocations"));
04961         callMessage << QVariant::fromValue(contacts);
04962         return this->connection().asyncCall(callMessage, timeout);
04963     }
04964 
04989     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
04990     {
04991         if (!invalidationReason().isEmpty()) {
04992             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
04993                 invalidationReason(),
04994                 invalidationMessage()
04995             ));
04996         }
04997 
04998         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04999                 this->staticInterfaceName(), QLatin1String("RequestLocation"));
05000         callMessage << QVariant::fromValue(contact);
05001         return this->connection().asyncCall(callMessage, timeout);
05002     }
05003 
05025     inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
05026     {
05027         if (!invalidationReason().isEmpty()) {
05028             return QDBusPendingReply<>(QDBusMessage::createError(
05029                 invalidationReason(),
05030                 invalidationMessage()
05031             ));
05032         }
05033 
05034         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05035                 this->staticInterfaceName(), QLatin1String("SetLocation"));
05036         callMessage << QVariant::fromValue(location);
05037         return this->connection().asyncCall(callMessage, timeout);
05038     }
05039 
05040 Q_SIGNALS:
05055     void LocationUpdated(uint contact, const QVariantMap& location);
05056 
05057 protected:
05058     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05059 };
05060 
05068 class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
05069 {
05070     Q_OBJECT
05071 
05072 public:
05079     static inline QLatin1String staticInterfaceName()
05080     {
05081         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving.DRAFT");
05082     }
05083 
05091     ConnectionInterfacePowerSavingInterface(
05092         const QString& busName,
05093         const QString& objectPath,
05094         QObject* parent = 0
05095     );
05096 
05105     ConnectionInterfacePowerSavingInterface(
05106         const QDBusConnection& connection,
05107         const QString& busName,
05108         const QString& objectPath,
05109         QObject* parent = 0
05110     );
05111 
05118     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
05119 
05127     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
05128 
05136     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05137 
05151     inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
05152     {
05153         return internalRequestProperty(QLatin1String("PowerSavingActive"));
05154     }
05155 
05162     Tp::PendingVariantMap *requestAllProperties() const
05163     {
05164         return internalRequestAllProperties();
05165     }
05166 
05167 public Q_SLOTS:
05199     inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
05200     {
05201         if (!invalidationReason().isEmpty()) {
05202             return QDBusPendingReply<>(QDBusMessage::createError(
05203                 invalidationReason(),
05204                 invalidationMessage()
05205             ));
05206         }
05207 
05208         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05209                 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
05210         callMessage << QVariant::fromValue(activate);
05211         return this->connection().asyncCall(callMessage, timeout);
05212     }
05213 
05214 Q_SIGNALS:
05225     void PowerSavingChanged(bool active);
05226 
05227 protected:
05228     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05229 };
05230 
05238 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
05239 {
05240     Q_OBJECT
05241 
05242 public:
05249     static inline QLatin1String staticInterfaceName()
05250     {
05251         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
05252     }
05253 
05261     ConnectionInterfacePresenceInterface(
05262         const QString& busName,
05263         const QString& objectPath,
05264         QObject* parent = 0
05265     );
05266 
05275     ConnectionInterfacePresenceInterface(
05276         const QDBusConnection& connection,
05277         const QString& busName,
05278         const QString& objectPath,
05279         QObject* parent = 0
05280     );
05281 
05288     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
05289 
05297     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
05298 
05306     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05307 
05314     Tp::PendingVariantMap *requestAllProperties() const
05315     {
05316         return internalRequestAllProperties();
05317     }
05318 
05319 public Q_SLOTS:
05341     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
05342     {
05343         if (!invalidationReason().isEmpty()) {
05344             return QDBusPendingReply<>(QDBusMessage::createError(
05345                 invalidationReason(),
05346                 invalidationMessage()
05347             ));
05348         }
05349 
05350         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05351                 this->staticInterfaceName(), QLatin1String("AddStatus"));
05352         callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
05353         return this->connection().asyncCall(callMessage, timeout);
05354     }
05355 
05369     inline QDBusPendingReply<> ClearStatus(int timeout = -1)
05370     {
05371         if (!invalidationReason().isEmpty()) {
05372             return QDBusPendingReply<>(QDBusMessage::createError(
05373                 invalidationReason(),
05374                 invalidationMessage()
05375             ));
05376         }
05377 
05378         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05379                 this->staticInterfaceName(), QLatin1String("ClearStatus"));
05380         return this->connection().asyncCall(callMessage, timeout);
05381     }
05382 
05406     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
05407     {
05408         if (!invalidationReason().isEmpty()) {
05409             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
05410                 invalidationReason(),
05411                 invalidationMessage()
05412             ));
05413         }
05414 
05415         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05416                 this->staticInterfaceName(), QLatin1String("GetPresence"));
05417         callMessage << QVariant::fromValue(contacts);
05418         return this->connection().asyncCall(callMessage, timeout);
05419     }
05420 
05442     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
05443     {
05444         if (!invalidationReason().isEmpty()) {
05445             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
05446                 invalidationReason(),
05447                 invalidationMessage()
05448             ));
05449         }
05450 
05451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05452                 this->staticInterfaceName(), QLatin1String("GetStatuses"));
05453         return this->connection().asyncCall(callMessage, timeout);
05454     }
05455 
05474     inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
05475     {
05476         if (!invalidationReason().isEmpty()) {
05477             return QDBusPendingReply<>(QDBusMessage::createError(
05478                 invalidationReason(),
05479                 invalidationMessage()
05480             ));
05481         }
05482 
05483         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05484                 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
05485         callMessage << QVariant::fromValue(status);
05486         return this->connection().asyncCall(callMessage, timeout);
05487     }
05488 
05507     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
05508     {
05509         if (!invalidationReason().isEmpty()) {
05510             return QDBusPendingReply<>(QDBusMessage::createError(
05511                 invalidationReason(),
05512                 invalidationMessage()
05513             ));
05514         }
05515 
05516         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05517                 this->staticInterfaceName(), QLatin1String("RequestPresence"));
05518         callMessage << QVariant::fromValue(contacts);
05519         return this->connection().asyncCall(callMessage, timeout);
05520     }
05521 
05537     inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
05538     {
05539         if (!invalidationReason().isEmpty()) {
05540             return QDBusPendingReply<>(QDBusMessage::createError(
05541                 invalidationReason(),
05542                 invalidationMessage()
05543             ));
05544         }
05545 
05546         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05547                 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
05548         callMessage << QVariant::fromValue(time);
05549         return this->connection().asyncCall(callMessage, timeout);
05550     }
05551 
05587     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
05588     {
05589         if (!invalidationReason().isEmpty()) {
05590             return QDBusPendingReply<>(QDBusMessage::createError(
05591                 invalidationReason(),
05592                 invalidationMessage()
05593             ));
05594         }
05595 
05596         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05597                 this->staticInterfaceName(), QLatin1String("SetStatus"));
05598         callMessage << QVariant::fromValue(statuses);
05599         return this->connection().asyncCall(callMessage, timeout);
05600     }
05601 
05602 Q_SIGNALS:
05619     void PresenceUpdate(const Tp::ContactPresences& presence);
05620 
05621 protected:
05622     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05623 };
05624 
05632 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
05633 {
05634     Q_OBJECT
05635 
05636 public:
05643     static inline QLatin1String staticInterfaceName()
05644     {
05645         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
05646     }
05647 
05655     ConnectionInterfaceRequestsInterface(
05656         const QString& busName,
05657         const QString& objectPath,
05658         QObject* parent = 0
05659     );
05660 
05669     ConnectionInterfaceRequestsInterface(
05670         const QDBusConnection& connection,
05671         const QString& busName,
05672         const QString& objectPath,
05673         QObject* parent = 0
05674     );
05675 
05682     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
05683 
05691     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
05692 
05700     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05701 
05712     inline Tp::PendingVariant *requestPropertyChannels() const
05713     {
05714         return internalRequestProperty(QLatin1String("Channels"));
05715     }
05716 
05744     inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
05745     {
05746         return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
05747     }
05748 
05755     Tp::PendingVariantMap *requestAllProperties() const
05756     {
05757         return internalRequestAllProperties();
05758     }
05759 
05760 public Q_SLOTS:
05834     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
05835     {
05836         if (!invalidationReason().isEmpty()) {
05837             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
05838                 invalidationReason(),
05839                 invalidationMessage()
05840             ));
05841         }
05842 
05843         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05844                 this->staticInterfaceName(), QLatin1String("CreateChannel"));
05845         callMessage << QVariant::fromValue(request);
05846         return this->connection().asyncCall(callMessage, timeout);
05847     }
05848 
05905     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
05906     {
05907         if (!invalidationReason().isEmpty()) {
05908             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
05909                 invalidationReason(),
05910                 invalidationMessage()
05911             ));
05912         }
05913 
05914         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05915                 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
05916         callMessage << QVariant::fromValue(request);
05917         return this->connection().asyncCall(callMessage, timeout);
05918     }
05919 
05920 Q_SIGNALS:
05962     void NewChannels(const Tp::ChannelDetailsList& channels);
05963 
05976     void ChannelClosed(const QDBusObjectPath& removed);
05977 
05978 protected:
05979     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05980 };
05981 
05989 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
05990 {
05991     Q_OBJECT
05992 
05993 public:
06000     static inline QLatin1String staticInterfaceName()
06001     {
06002         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
06003     }
06004 
06012     ConnectionInterfaceServicePointInterface(
06013         const QString& busName,
06014         const QString& objectPath,
06015         QObject* parent = 0
06016     );
06017 
06026     ConnectionInterfaceServicePointInterface(
06027         const QDBusConnection& connection,
06028         const QString& busName,
06029         const QString& objectPath,
06030         QObject* parent = 0
06031     );
06032 
06039     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
06040 
06048     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
06049 
06057     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06058 
06068     inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
06069     {
06070         return internalRequestProperty(QLatin1String("KnownServicePoints"));
06071     }
06072 
06079     Tp::PendingVariantMap *requestAllProperties() const
06080     {
06081         return internalRequestAllProperties();
06082     }
06083 
06084 Q_SIGNALS:
06096     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
06097 
06098 protected:
06099     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06100 };
06101 
06109 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
06110 {
06111     Q_OBJECT
06112 
06113 public:
06120     static inline QLatin1String staticInterfaceName()
06121     {
06122         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
06123     }
06124 
06132     ConnectionInterfaceSimplePresenceInterface(
06133         const QString& busName,
06134         const QString& objectPath,
06135         QObject* parent = 0
06136     );
06137 
06146     ConnectionInterfaceSimplePresenceInterface(
06147         const QDBusConnection& connection,
06148         const QString& busName,
06149         const QString& objectPath,
06150         QObject* parent = 0
06151     );
06152 
06159     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
06160 
06168     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06169 
06177     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06178 
06218     inline Tp::PendingVariant *requestPropertyStatuses() const
06219     {
06220         return internalRequestProperty(QLatin1String("Statuses"));
06221     }
06222 
06229     Tp::PendingVariantMap *requestAllProperties() const
06230     {
06231         return internalRequestAllProperties();
06232     }
06233 
06234 public Q_SLOTS:
06294     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
06295     {
06296         if (!invalidationReason().isEmpty()) {
06297             return QDBusPendingReply<>(QDBusMessage::createError(
06298                 invalidationReason(),
06299                 invalidationMessage()
06300             ));
06301         }
06302 
06303         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06304                 this->staticInterfaceName(), QLatin1String("SetPresence"));
06305         callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
06306         return this->connection().asyncCall(callMessage, timeout);
06307     }
06308 
06338     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
06339     {
06340         if (!invalidationReason().isEmpty()) {
06341             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
06342                 invalidationReason(),
06343                 invalidationMessage()
06344             ));
06345         }
06346 
06347         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06348                 this->staticInterfaceName(), QLatin1String("GetPresences"));
06349         callMessage << QVariant::fromValue(contacts);
06350         return this->connection().asyncCall(callMessage, timeout);
06351     }
06352 
06353 Q_SIGNALS:
06366     void PresencesChanged(const Tp::SimpleContactPresences& presence);
06367 
06368 protected:
06369     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06370 };
06371 }
06372 }
06373 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
06374 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
06375 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
06376 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
06377 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
06378 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
06379 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
06380 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
06381 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
06382 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
06383 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
06384 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
06385 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
06386 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
06387 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
06388 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
06389 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
06390 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
06391 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


Copyright © 2008-2010 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.5.1