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


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