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 
00936     void ConnectionError(const QString& error, const QVariantMap& details);
00937 
00954     void StatusChanged(uint status, uint reason);
00955 
00956 protected:
00957     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00958 };
00959 
00967 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00968 {
00969     Q_OBJECT
00970 
00971 public:
00978     static inline QLatin1String staticInterfaceName()
00979     {
00980         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
00981     }
00982 
00990     ConnectionInterfaceAliasingInterface(
00991         const QString& busName,
00992         const QString& objectPath,
00993         QObject* parent = 0
00994     );
00995 
01004     ConnectionInterfaceAliasingInterface(
01005         const QDBusConnection& connection,
01006         const QString& busName,
01007         const QString& objectPath,
01008         QObject* parent = 0
01009     );
01010 
01017     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
01018 
01026     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
01027 
01035     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01036 
01043     Tp::PendingVariantMap *requestAllProperties() const
01044     {
01045         return internalRequestAllProperties();
01046     }
01047 
01048 public Q_SLOTS:
01064     inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
01065     {
01066         if (!invalidationReason().isEmpty()) {
01067             return QDBusPendingReply<uint>(QDBusMessage::createError(
01068                 invalidationReason(),
01069                 invalidationMessage()
01070             ));
01071         }
01072 
01073         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01074                 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
01075         return this->connection().asyncCall(callMessage, timeout);
01076     }
01077 
01096     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
01097     {
01098         if (!invalidationReason().isEmpty()) {
01099             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01100                 invalidationReason(),
01101                 invalidationMessage()
01102             ));
01103         }
01104 
01105         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01106                 this->staticInterfaceName(), QLatin1String("RequestAliases"));
01107         callMessage << QVariant::fromValue(contacts);
01108         return this->connection().asyncCall(callMessage, timeout);
01109     }
01110 
01133     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
01134     {
01135         if (!invalidationReason().isEmpty()) {
01136             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
01137                 invalidationReason(),
01138                 invalidationMessage()
01139             ));
01140         }
01141 
01142         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01143                 this->staticInterfaceName(), QLatin1String("GetAliases"));
01144         callMessage << QVariant::fromValue(contacts);
01145         return this->connection().asyncCall(callMessage, timeout);
01146     }
01147 
01167     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
01168     {
01169         if (!invalidationReason().isEmpty()) {
01170             return QDBusPendingReply<>(QDBusMessage::createError(
01171                 invalidationReason(),
01172                 invalidationMessage()
01173             ));
01174         }
01175 
01176         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01177                 this->staticInterfaceName(), QLatin1String("SetAliases"));
01178         callMessage << QVariant::fromValue(aliases);
01179         return this->connection().asyncCall(callMessage, timeout);
01180     }
01181 
01182 Q_SIGNALS:
01197     void AliasesChanged(const Tp::AliasPairList& aliases);
01198 
01199 protected:
01200     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01201 };
01202 
01210 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
01211 {
01212     Q_OBJECT
01213 
01214 public:
01221     static inline QLatin1String staticInterfaceName()
01222     {
01223         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
01224     }
01225 
01233     ConnectionInterfaceAnonymityInterface(
01234         const QString& busName,
01235         const QString& objectPath,
01236         QObject* parent = 0
01237     );
01238 
01247     ConnectionInterfaceAnonymityInterface(
01248         const QDBusConnection& connection,
01249         const QString& busName,
01250         const QString& objectPath,
01251         QObject* parent = 0
01252     );
01253 
01260     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
01261 
01269     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01270 
01278     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01279 
01290     inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
01291     {
01292         return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
01293     }
01294 
01310     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
01311     {
01312         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
01313     }
01314 
01330     inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
01331     {
01332         return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
01333     }
01334 
01347     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
01348     {
01349         return internalRequestProperty(QLatin1String("AnonymityModes"));
01350     }
01351 
01364     inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
01365     {
01366         return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
01367     }
01368 
01375     Tp::PendingVariantMap *requestAllProperties() const
01376     {
01377         return internalRequestAllProperties();
01378     }
01379 
01380 Q_SIGNALS:
01390     void AnonymityModesChanged(uint modes);
01391 
01392 protected:
01393     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01394 };
01395 
01403 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01404 {
01405     Q_OBJECT
01406 
01407 public:
01414     static inline QLatin1String staticInterfaceName()
01415     {
01416         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
01417     }
01418 
01426     ConnectionInterfaceAvatarsInterface(
01427         const QString& busName,
01428         const QString& objectPath,
01429         QObject* parent = 0
01430     );
01431 
01440     ConnectionInterfaceAvatarsInterface(
01441         const QDBusConnection& connection,
01442         const QString& busName,
01443         const QString& objectPath,
01444         QObject* parent = 0
01445     );
01446 
01453     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01454 
01462     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01463 
01471     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01472 
01484     inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
01485     {
01486         return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
01487     }
01488 
01500     inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
01501     {
01502         return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
01503     }
01504 
01516     inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
01517     {
01518         return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
01519     }
01520 
01535     inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
01536     {
01537         return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
01538     }
01539 
01552     inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
01553     {
01554         return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
01555     }
01556 
01568     inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
01569     {
01570         return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
01571     }
01572 
01584     inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
01585     {
01586         return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
01587     }
01588 
01600     inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
01601     {
01602         return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
01603     }
01604 
01611     Tp::PendingVariantMap *requestAllProperties() const
01612     {
01613         return internalRequestAllProperties();
01614     }
01615 
01616 public Q_SLOTS:
01651     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
01652     {
01653         if (!invalidationReason().isEmpty()) {
01654             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01655                 invalidationReason(),
01656                 invalidationMessage()
01657             ));
01658         }
01659 
01660         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01661                 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
01662         return this->connection().asyncCall(callMessage, timeout);
01663     }
01664 
01686     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01687     {
01688         if (!invalidationReason().isEmpty()) {
01689             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01690                 invalidationReason(),
01691                 invalidationMessage()
01692             ));
01693         }
01694 
01695         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01696                 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
01697         callMessage << QVariant::fromValue(contacts);
01698         return this->connection().asyncCall(callMessage, timeout);
01699     }
01700 
01728     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
01729     {
01730         if (!invalidationReason().isEmpty()) {
01731             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01732                 invalidationReason(),
01733                 invalidationMessage()
01734             ));
01735         }
01736 
01737         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01738                 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
01739         callMessage << QVariant::fromValue(contacts);
01740         return this->connection().asyncCall(callMessage, timeout);
01741     }
01742 
01767     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
01768     {
01769         if (!invalidationReason().isEmpty()) {
01770             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01771                 invalidationReason(),
01772                 invalidationMessage()
01773             ));
01774         }
01775 
01776         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01777                 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
01778         callMessage << QVariant::fromValue(contact);
01779         return this->connection().asyncCall(callMessage, timeout);
01780     }
01781 
01800     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
01801     {
01802         if (!invalidationReason().isEmpty()) {
01803             return QDBusPendingReply<>(QDBusMessage::createError(
01804                 invalidationReason(),
01805                 invalidationMessage()
01806             ));
01807         }
01808 
01809         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01810                 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
01811         callMessage << QVariant::fromValue(contacts);
01812         return this->connection().asyncCall(callMessage, timeout);
01813     }
01814 
01838     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
01839     {
01840         if (!invalidationReason().isEmpty()) {
01841             return QDBusPendingReply<QString>(QDBusMessage::createError(
01842                 invalidationReason(),
01843                 invalidationMessage()
01844             ));
01845         }
01846 
01847         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01848                 this->staticInterfaceName(), QLatin1String("SetAvatar"));
01849         callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01850         return this->connection().asyncCall(callMessage, timeout);
01851     }
01852 
01863     inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
01864     {
01865         if (!invalidationReason().isEmpty()) {
01866             return QDBusPendingReply<>(QDBusMessage::createError(
01867                 invalidationReason(),
01868                 invalidationMessage()
01869             ));
01870         }
01871 
01872         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01873                 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
01874         return this->connection().asyncCall(callMessage, timeout);
01875     }
01876 
01877 Q_SIGNALS:
01894     void AvatarUpdated(uint contact, const QString& newAvatarToken);
01895 
01918     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01919 
01920 protected:
01921     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01922 };
01923 
01931 class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01932 {
01933     Q_OBJECT
01934 
01935 public:
01942     static inline QLatin1String staticInterfaceName()
01943     {
01944         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
01945     }
01946 
01954     ConnectionInterfaceBalanceInterface(
01955         const QString& busName,
01956         const QString& objectPath,
01957         QObject* parent = 0
01958     );
01959 
01968     ConnectionInterfaceBalanceInterface(
01969         const QDBusConnection& connection,
01970         const QString& busName,
01971         const QString& objectPath,
01972         QObject* parent = 0
01973     );
01974 
01981     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
01982 
01990     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01991 
01999     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02000 
02017     inline Tp::PendingVariant *requestPropertyAccountBalance() const
02018     {
02019         return internalRequestProperty(QLatin1String("AccountBalance"));
02020     }
02021 
02028     Tp::PendingVariantMap *requestAllProperties() const
02029     {
02030         return internalRequestAllProperties();
02031     }
02032 
02033 Q_SIGNALS:
02044     void BalanceChanged(const Tp::CurrencyAmount& balance);
02045 
02046 protected:
02047     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02048 };
02049 
02057 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
02058 {
02059     Q_OBJECT
02060 
02061 public:
02068     static inline QLatin1String staticInterfaceName()
02069     {
02070         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
02071     }
02072 
02080     ConnectionInterfaceCapabilitiesInterface(
02081         const QString& busName,
02082         const QString& objectPath,
02083         QObject* parent = 0
02084     );
02085 
02094     ConnectionInterfaceCapabilitiesInterface(
02095         const QDBusConnection& connection,
02096         const QString& busName,
02097         const QString& objectPath,
02098         QObject* parent = 0
02099     );
02100 
02107     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
02108 
02116     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02117 
02125     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02126 
02133     Tp::PendingVariantMap *requestAllProperties() const
02134     {
02135         return internalRequestAllProperties();
02136     }
02137 
02138 public Q_SLOTS:
02188     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
02189     {
02190         if (!invalidationReason().isEmpty()) {
02191             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
02192                 invalidationReason(),
02193                 invalidationMessage()
02194             ));
02195         }
02196 
02197         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02198                 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
02199         callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
02200         return this->connection().asyncCall(callMessage, timeout);
02201     }
02202 
02233     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
02234     {
02235         if (!invalidationReason().isEmpty()) {
02236             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
02237                 invalidationReason(),
02238                 invalidationMessage()
02239             ));
02240         }
02241 
02242         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02243                 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
02244         callMessage << QVariant::fromValue(handles);
02245         return this->connection().asyncCall(callMessage, timeout);
02246     }
02247 
02248 Q_SIGNALS:
02271     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
02272 
02273 protected:
02274     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02275 };
02276 
02284 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
02285 {
02286     Q_OBJECT
02287 
02288 public:
02295     static inline QLatin1String staticInterfaceName()
02296     {
02297         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
02298     }
02299 
02307     ConnectionInterfaceCellularInterface(
02308         const QString& busName,
02309         const QString& objectPath,
02310         QObject* parent = 0
02311     );
02312 
02321     ConnectionInterfaceCellularInterface(
02322         const QDBusConnection& connection,
02323         const QString& busName,
02324         const QString& objectPath,
02325         QObject* parent = 0
02326     );
02327 
02334     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02335 
02343     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02344 
02352     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02353 
02370     inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
02371     {
02372         return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
02373     }
02374 
02391     inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
02392     {
02393         return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
02394     }
02395 
02416     inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
02417     {
02418         return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
02419     }
02420 
02441     inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
02442     {
02443         return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
02444     }
02445 
02460     inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
02461     {
02462         return internalRequestProperty(QLatin1String("MessageServiceCentre"));
02463     }
02464 
02479     inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
02480     {
02481         return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
02482     }
02483 
02495     inline Tp::PendingVariant *requestPropertyIMSI() const
02496     {
02497         return internalRequestProperty(QLatin1String("IMSI"));
02498     }
02499 
02515     inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
02516     {
02517         return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
02518     }
02519 
02535     inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
02536     {
02537         return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
02538     }
02539 
02546     Tp::PendingVariantMap *requestAllProperties() const
02547     {
02548         return internalRequestAllProperties();
02549     }
02550 
02551 Q_SIGNALS:
02567     void IMSIChanged(const QString& IMSI);
02568 
02569 protected:
02570     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02571 };
02572 
02580 class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
02581 {
02582     Q_OBJECT
02583 
02584 public:
02591     static inline QLatin1String staticInterfaceName()
02592     {
02593         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
02594     }
02595 
02603     ConnectionInterfaceClientTypesInterface(
02604         const QString& busName,
02605         const QString& objectPath,
02606         QObject* parent = 0
02607     );
02608 
02617     ConnectionInterfaceClientTypesInterface(
02618         const QDBusConnection& connection,
02619         const QString& busName,
02620         const QString& objectPath,
02621         QObject* parent = 0
02622     );
02623 
02630     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
02631 
02639     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02640 
02648     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02649 
02656     Tp::PendingVariantMap *requestAllProperties() const
02657     {
02658         return internalRequestAllProperties();
02659     }
02660 
02661 public Q_SLOTS:
02690     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
02691     {
02692         if (!invalidationReason().isEmpty()) {
02693             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
02694                 invalidationReason(),
02695                 invalidationMessage()
02696             ));
02697         }
02698 
02699         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02700                 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
02701         callMessage << QVariant::fromValue(contacts);
02702         return this->connection().asyncCall(callMessage, timeout);
02703     }
02704 
02729     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
02730     {
02731         if (!invalidationReason().isEmpty()) {
02732             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02733                 invalidationReason(),
02734                 invalidationMessage()
02735             ));
02736         }
02737 
02738         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02739                 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
02740         callMessage << QVariant::fromValue(contact);
02741         return this->connection().asyncCall(callMessage, timeout);
02742     }
02743 
02744 Q_SIGNALS:
02759     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
02760 
02761 protected:
02762     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02763 };
02764 
02772 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
02773 {
02774     Q_OBJECT
02775 
02776 public:
02783     static inline QLatin1String staticInterfaceName()
02784     {
02785         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
02786     }
02787 
02795     ConnectionInterfaceContactCapabilitiesInterface(
02796         const QString& busName,
02797         const QString& objectPath,
02798         QObject* parent = 0
02799     );
02800 
02809     ConnectionInterfaceContactCapabilitiesInterface(
02810         const QDBusConnection& connection,
02811         const QString& busName,
02812         const QString& objectPath,
02813         QObject* parent = 0
02814     );
02815 
02822     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
02823 
02831     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02832 
02840     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02841 
02848     Tp::PendingVariantMap *requestAllProperties() const
02849     {
02850         return internalRequestAllProperties();
02851     }
02852 
02853 public Q_SLOTS:
02914     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
02915     {
02916         if (!invalidationReason().isEmpty()) {
02917             return QDBusPendingReply<>(QDBusMessage::createError(
02918                 invalidationReason(),
02919                 invalidationMessage()
02920             ));
02921         }
02922 
02923         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02924                 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
02925         callMessage << QVariant::fromValue(handlerCapabilities);
02926         return this->connection().asyncCall(callMessage, timeout);
02927     }
02928 
02958     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
02959     {
02960         if (!invalidationReason().isEmpty()) {
02961             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
02962                 invalidationReason(),
02963                 invalidationMessage()
02964             ));
02965         }
02966 
02967         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02968                 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
02969         callMessage << QVariant::fromValue(handles);
02970         return this->connection().asyncCall(callMessage, timeout);
02971     }
02972 
02973 Q_SIGNALS:
02990     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
02991 
02992 protected:
02993     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02994 };
02995 
03003 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
03004 {
03005     Q_OBJECT
03006 
03007 public:
03014     static inline QLatin1String staticInterfaceName()
03015     {
03016         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
03017     }
03018 
03026     ConnectionInterfaceContactGroupsInterface(
03027         const QString& busName,
03028         const QString& objectPath,
03029         QObject* parent = 0
03030     );
03031 
03040     ConnectionInterfaceContactGroupsInterface(
03041         const QDBusConnection& connection,
03042         const QString& busName,
03043         const QString& objectPath,
03044         QObject* parent = 0
03045     );
03046 
03053     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
03054 
03062     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03063 
03071     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03072 
03087     inline Tp::PendingVariant *requestPropertyDisjointGroups() const
03088     {
03089         return internalRequestProperty(QLatin1String("DisjointGroups"));
03090     }
03091 
03104     inline Tp::PendingVariant *requestPropertyGroupStorage() const
03105     {
03106         return internalRequestProperty(QLatin1String("GroupStorage"));
03107     }
03108 
03130     inline Tp::PendingVariant *requestPropertyGroups() const
03131     {
03132         return internalRequestProperty(QLatin1String("Groups"));
03133     }
03134 
03141     Tp::PendingVariantMap *requestAllProperties() const
03142     {
03143         return internalRequestAllProperties();
03144     }
03145 
03146 public Q_SLOTS:
03193     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
03194     {
03195         if (!invalidationReason().isEmpty()) {
03196             return QDBusPendingReply<>(QDBusMessage::createError(
03197                 invalidationReason(),
03198                 invalidationMessage()
03199             ));
03200         }
03201 
03202         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03203                 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
03204         callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
03205         return this->connection().asyncCall(callMessage, timeout);
03206     }
03207 
03253     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
03254     {
03255         if (!invalidationReason().isEmpty()) {
03256             return QDBusPendingReply<>(QDBusMessage::createError(
03257                 invalidationReason(),
03258                 invalidationMessage()
03259             ));
03260         }
03261 
03262         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03263                 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
03264         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03265         return this->connection().asyncCall(callMessage, timeout);
03266     }
03267 
03306     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03307     {
03308         if (!invalidationReason().isEmpty()) {
03309             return QDBusPendingReply<>(QDBusMessage::createError(
03310                 invalidationReason(),
03311                 invalidationMessage()
03312             ));
03313         }
03314 
03315         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03316                 this->staticInterfaceName(), QLatin1String("AddToGroup"));
03317         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03318         return this->connection().asyncCall(callMessage, timeout);
03319     }
03320 
03358     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
03359     {
03360         if (!invalidationReason().isEmpty()) {
03361             return QDBusPendingReply<>(QDBusMessage::createError(
03362                 invalidationReason(),
03363                 invalidationMessage()
03364             ));
03365         }
03366 
03367         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03368                 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
03369         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
03370         return this->connection().asyncCall(callMessage, timeout);
03371     }
03372 
03399     inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
03400     {
03401         if (!invalidationReason().isEmpty()) {
03402             return QDBusPendingReply<>(QDBusMessage::createError(
03403                 invalidationReason(),
03404                 invalidationMessage()
03405             ));
03406         }
03407 
03408         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03409                 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
03410         callMessage << QVariant::fromValue(group);
03411         return this->connection().asyncCall(callMessage, timeout);
03412     }
03413 
03451     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
03452     {
03453         if (!invalidationReason().isEmpty()) {
03454             return QDBusPendingReply<>(QDBusMessage::createError(
03455                 invalidationReason(),
03456                 invalidationMessage()
03457             ));
03458         }
03459 
03460         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03461                 this->staticInterfaceName(), QLatin1String("RenameGroup"));
03462         callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
03463         return this->connection().asyncCall(callMessage, timeout);
03464     }
03465 
03466 Q_SIGNALS:
03484     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
03485 
03496     void GroupsCreated(const QStringList& names);
03497 
03543     void GroupRenamed(const QString& oldName, const QString& newName);
03544 
03569     void GroupsRemoved(const QStringList& names);
03570 
03571 protected:
03572     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03573 };
03574 
03582 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
03583 {
03584     Q_OBJECT
03585 
03586 public:
03593     static inline QLatin1String staticInterfaceName()
03594     {
03595         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
03596     }
03597 
03605     ConnectionInterfaceContactInfoInterface(
03606         const QString& busName,
03607         const QString& objectPath,
03608         QObject* parent = 0
03609     );
03610 
03619     ConnectionInterfaceContactInfoInterface(
03620         const QDBusConnection& connection,
03621         const QString& busName,
03622         const QString& objectPath,
03623         QObject* parent = 0
03624     );
03625 
03632     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
03633 
03641     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
03642 
03650     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03651 
03673     inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
03674     {
03675         return internalRequestProperty(QLatin1String("ContactInfoFlags"));
03676     }
03677 
03733     inline Tp::PendingVariant *requestPropertySupportedFields() const
03734     {
03735         return internalRequestProperty(QLatin1String("SupportedFields"));
03736     }
03737 
03744     Tp::PendingVariantMap *requestAllProperties() const
03745     {
03746         return internalRequestAllProperties();
03747     }
03748 
03749 public Q_SLOTS:
03772     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
03773     {
03774         if (!invalidationReason().isEmpty()) {
03775             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
03776                 invalidationReason(),
03777                 invalidationMessage()
03778             ));
03779         }
03780 
03781         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03782                 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
03783         callMessage << QVariant::fromValue(contacts);
03784         return this->connection().asyncCall(callMessage, timeout);
03785     }
03786 
03806     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
03807     {
03808         if (!invalidationReason().isEmpty()) {
03809             return QDBusPendingReply<>(QDBusMessage::createError(
03810                 invalidationReason(),
03811                 invalidationMessage()
03812             ));
03813         }
03814 
03815         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03816                 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
03817         callMessage << QVariant::fromValue(contacts);
03818         return this->connection().asyncCall(callMessage, timeout);
03819     }
03820 
03842     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
03843     {
03844         if (!invalidationReason().isEmpty()) {
03845             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
03846                 invalidationReason(),
03847                 invalidationMessage()
03848             ));
03849         }
03850 
03851         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03852                 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
03853         callMessage << QVariant::fromValue(contact);
03854         return this->connection().asyncCall(callMessage, timeout);
03855     }
03856 
03874     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
03875     {
03876         if (!invalidationReason().isEmpty()) {
03877             return QDBusPendingReply<>(QDBusMessage::createError(
03878                 invalidationReason(),
03879                 invalidationMessage()
03880             ));
03881         }
03882 
03883         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03884                 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
03885         callMessage << QVariant::fromValue(contactInfo);
03886         return this->connection().asyncCall(callMessage, timeout);
03887     }
03888 
03889 Q_SIGNALS:
03904     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
03905 
03906 protected:
03907     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03908 };
03909 
03917 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
03918 {
03919     Q_OBJECT
03920 
03921 public:
03928     static inline QLatin1String staticInterfaceName()
03929     {
03930         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
03931     }
03932 
03940     ConnectionInterfaceContactListInterface(
03941         const QString& busName,
03942         const QString& objectPath,
03943         QObject* parent = 0
03944     );
03945 
03954     ConnectionInterfaceContactListInterface(
03955         const QDBusConnection& connection,
03956         const QString& busName,
03957         const QString& objectPath,
03958         QObject* parent = 0
03959     );
03960 
03967     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
03968 
03976     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
03977 
03985     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03986 
03997     inline Tp::PendingVariant *requestPropertyContactListState() const
03998     {
03999         return internalRequestProperty(QLatin1String("ContactListState"));
04000     }
04001 
04059     inline Tp::PendingVariant *requestPropertyContactListPersists() const
04060     {
04061         return internalRequestProperty(QLatin1String("ContactListPersists"));
04062     }
04063 
04090     inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
04091     {
04092         return internalRequestProperty(QLatin1String("CanChangeContactList"));
04093     }
04094 
04121     inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
04122     {
04123         return internalRequestProperty(QLatin1String("RequestUsesMessage"));
04124     }
04125 
04132     Tp::PendingVariantMap *requestAllProperties() const
04133     {
04134         return internalRequestAllProperties();
04135     }
04136 
04137 public Q_SLOTS:
04201     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
04202     {
04203         if (!invalidationReason().isEmpty()) {
04204             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04205                 invalidationReason(),
04206                 invalidationMessage()
04207             ));
04208         }
04209 
04210         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04211                 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
04212         callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04213         return this->connection().asyncCall(callMessage, timeout);
04214     }
04215 
04320     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
04321     {
04322         if (!invalidationReason().isEmpty()) {
04323             return QDBusPendingReply<>(QDBusMessage::createError(
04324                 invalidationReason(),
04325                 invalidationMessage()
04326             ));
04327         }
04328 
04329         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04330                 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
04331         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
04332         return this->connection().asyncCall(callMessage, timeout);
04333     }
04334 
04402     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
04403     {
04404         if (!invalidationReason().isEmpty()) {
04405             return QDBusPendingReply<>(QDBusMessage::createError(
04406                 invalidationReason(),
04407                 invalidationMessage()
04408             ));
04409         }
04410 
04411         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04412                 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
04413         callMessage << QVariant::fromValue(contacts);
04414         return this->connection().asyncCall(callMessage, timeout);
04415     }
04416 
04462     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
04463     {
04464         if (!invalidationReason().isEmpty()) {
04465             return QDBusPendingReply<>(QDBusMessage::createError(
04466                 invalidationReason(),
04467                 invalidationMessage()
04468             ));
04469         }
04470 
04471         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04472                 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
04473         callMessage << QVariant::fromValue(contacts);
04474         return this->connection().asyncCall(callMessage, timeout);
04475     }
04476 
04509     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
04510     {
04511         if (!invalidationReason().isEmpty()) {
04512             return QDBusPendingReply<>(QDBusMessage::createError(
04513                 invalidationReason(),
04514                 invalidationMessage()
04515             ));
04516         }
04517 
04518         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04519                 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
04520         callMessage << QVariant::fromValue(contacts);
04521         return this->connection().asyncCall(callMessage, timeout);
04522     }
04523 
04556     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
04557     {
04558         if (!invalidationReason().isEmpty()) {
04559             return QDBusPendingReply<>(QDBusMessage::createError(
04560                 invalidationReason(),
04561                 invalidationMessage()
04562             ));
04563         }
04564 
04565         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04566                 this->staticInterfaceName(), QLatin1String("Unpublish"));
04567         callMessage << QVariant::fromValue(contacts);
04568         return this->connection().asyncCall(callMessage, timeout);
04569     }
04570 
04571 Q_SIGNALS:
04581     void ContactListStateChanged(uint contactListState);
04582 
04627     void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
04628 
04649     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
04650 
04651 protected:
04652     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04653 };
04654 
04662 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
04663 {
04664     Q_OBJECT
04665 
04666 public:
04673     static inline QLatin1String staticInterfaceName()
04674     {
04675         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
04676     }
04677 
04685     ConnectionInterfaceContactsInterface(
04686         const QString& busName,
04687         const QString& objectPath,
04688         QObject* parent = 0
04689     );
04690 
04699     ConnectionInterfaceContactsInterface(
04700         const QDBusConnection& connection,
04701         const QString& busName,
04702         const QString& objectPath,
04703         QObject* parent = 0
04704     );
04705 
04712     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
04713 
04721     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
04722 
04730     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04731 
04742     inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
04743     {
04744         return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
04745     }
04746 
04753     Tp::PendingVariantMap *requestAllProperties() const
04754     {
04755         return internalRequestAllProperties();
04756     }
04757 
04758 public Q_SLOTS:
04835     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
04836     {
04837         if (!invalidationReason().isEmpty()) {
04838             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04839                 invalidationReason(),
04840                 invalidationMessage()
04841             ));
04842         }
04843 
04844         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04845                 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
04846         callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04847         return this->connection().asyncCall(callMessage, timeout);
04848     }
04849 
04850 protected:
04851     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04852 };
04853 
04861 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
04862 {
04863     Q_OBJECT
04864 
04865 public:
04872     static inline QLatin1String staticInterfaceName()
04873     {
04874         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
04875     }
04876 
04884     ConnectionInterfaceLocationInterface(
04885         const QString& busName,
04886         const QString& objectPath,
04887         QObject* parent = 0
04888     );
04889 
04898     ConnectionInterfaceLocationInterface(
04899         const QDBusConnection& connection,
04900         const QString& busName,
04901         const QString& objectPath,
04902         QObject* parent = 0
04903     );
04904 
04911     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
04912 
04920     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
04921 
04929     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04930 
04940     inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
04941     {
04942         return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
04943     }
04944 
04957     inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
04958     {
04959         return internalRequestProperty(QLatin1String("LocationAccessControl"));
04960     }
04961 
04974     inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
04975     {
04976         return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
04977     }
04978 
04990     inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
04991     {
04992         return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
04993     }
04994 
05001     Tp::PendingVariantMap *requestAllProperties() const
05002     {
05003         return internalRequestAllProperties();
05004     }
05005 
05006 public Q_SLOTS:
05045     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
05046     {
05047         if (!invalidationReason().isEmpty()) {
05048             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
05049                 invalidationReason(),
05050                 invalidationMessage()
05051             ));
05052         }
05053 
05054         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05055                 this->staticInterfaceName(), QLatin1String("GetLocations"));
05056         callMessage << QVariant::fromValue(contacts);
05057         return this->connection().asyncCall(callMessage, timeout);
05058     }
05059 
05084     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
05085     {
05086         if (!invalidationReason().isEmpty()) {
05087             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
05088                 invalidationReason(),
05089                 invalidationMessage()
05090             ));
05091         }
05092 
05093         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05094                 this->staticInterfaceName(), QLatin1String("RequestLocation"));
05095         callMessage << QVariant::fromValue(contact);
05096         return this->connection().asyncCall(callMessage, timeout);
05097     }
05098 
05120     inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
05121     {
05122         if (!invalidationReason().isEmpty()) {
05123             return QDBusPendingReply<>(QDBusMessage::createError(
05124                 invalidationReason(),
05125                 invalidationMessage()
05126             ));
05127         }
05128 
05129         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05130                 this->staticInterfaceName(), QLatin1String("SetLocation"));
05131         callMessage << QVariant::fromValue(location);
05132         return this->connection().asyncCall(callMessage, timeout);
05133     }
05134 
05135 Q_SIGNALS:
05150     void LocationUpdated(uint contact, const QVariantMap& location);
05151 
05152 protected:
05153     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05154 };
05155 
05163 class TELEPATHY_QT4_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
05164 {
05165     Q_OBJECT
05166 
05167 public:
05174     static inline QLatin1String staticInterfaceName()
05175     {
05176         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
05177     }
05178 
05186     ConnectionInterfaceMailNotificationInterface(
05187         const QString& busName,
05188         const QString& objectPath,
05189         QObject* parent = 0
05190     );
05191 
05200     ConnectionInterfaceMailNotificationInterface(
05201         const QDBusConnection& connection,
05202         const QString& busName,
05203         const QString& objectPath,
05204         QObject* parent = 0
05205     );
05206 
05213     ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
05214 
05222     explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05223 
05231     ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05232 
05247     inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
05248     {
05249         return internalRequestProperty(QLatin1String("MailNotificationFlags"));
05250     }
05251 
05274     inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
05275     {
05276         return internalRequestProperty(QLatin1String("UnreadMailCount"));
05277     }
05278 
05295     inline Tp::PendingVariant *requestPropertyUnreadMails() const
05296     {
05297         return internalRequestProperty(QLatin1String("UnreadMails"));
05298     }
05299 
05314     inline Tp::PendingVariant *requestPropertyMailAddress() const
05315     {
05316         return internalRequestProperty(QLatin1String("MailAddress"));
05317     }
05318 
05325     Tp::PendingVariantMap *requestAllProperties() const
05326     {
05327         return internalRequestAllProperties();
05328     }
05329 
05330 public Q_SLOTS:
05354     inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
05355     {
05356         if (!invalidationReason().isEmpty()) {
05357             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05358                 invalidationReason(),
05359                 invalidationMessage()
05360             ));
05361         }
05362 
05363         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05364                 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
05365         return this->connection().asyncCall(callMessage, timeout);
05366     }
05367 
05397     inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
05398     {
05399         if (!invalidationReason().isEmpty()) {
05400             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
05401                 invalidationReason(),
05402                 invalidationMessage()
05403             ));
05404         }
05405 
05406         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05407                 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
05408         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
05409         return this->connection().asyncCall(callMessage, timeout);
05410     }
05411 
05412 Q_SIGNALS:
05433     void MailsReceived(const Tp::MailList& mails);
05434 
05472     void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
05473 
05474 protected:
05475     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05476 };
05477 
05485 class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
05486 {
05487     Q_OBJECT
05488 
05489 public:
05496     static inline QLatin1String staticInterfaceName()
05497     {
05498         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
05499     }
05500 
05508     ConnectionInterfacePowerSavingInterface(
05509         const QString& busName,
05510         const QString& objectPath,
05511         QObject* parent = 0
05512     );
05513 
05522     ConnectionInterfacePowerSavingInterface(
05523         const QDBusConnection& connection,
05524         const QString& busName,
05525         const QString& objectPath,
05526         QObject* parent = 0
05527     );
05528 
05535     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
05536 
05544     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
05545 
05553     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05554 
05568     inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
05569     {
05570         return internalRequestProperty(QLatin1String("PowerSavingActive"));
05571     }
05572 
05579     Tp::PendingVariantMap *requestAllProperties() const
05580     {
05581         return internalRequestAllProperties();
05582     }
05583 
05584 public Q_SLOTS:
05616     inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
05617     {
05618         if (!invalidationReason().isEmpty()) {
05619             return QDBusPendingReply<>(QDBusMessage::createError(
05620                 invalidationReason(),
05621                 invalidationMessage()
05622             ));
05623         }
05624 
05625         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05626                 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
05627         callMessage << QVariant::fromValue(activate);
05628         return this->connection().asyncCall(callMessage, timeout);
05629     }
05630 
05631 Q_SIGNALS:
05642     void PowerSavingChanged(bool active);
05643 
05644 protected:
05645     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05646 };
05647 
05655 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
05656 {
05657     Q_OBJECT
05658 
05659 public:
05666     static inline QLatin1String staticInterfaceName()
05667     {
05668         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
05669     }
05670 
05678     ConnectionInterfacePresenceInterface(
05679         const QString& busName,
05680         const QString& objectPath,
05681         QObject* parent = 0
05682     );
05683 
05692     ConnectionInterfacePresenceInterface(
05693         const QDBusConnection& connection,
05694         const QString& busName,
05695         const QString& objectPath,
05696         QObject* parent = 0
05697     );
05698 
05705     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
05706 
05714     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
05715 
05723     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05724 
05731     Tp::PendingVariantMap *requestAllProperties() const
05732     {
05733         return internalRequestAllProperties();
05734     }
05735 
05736 public Q_SLOTS:
05758     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
05759     {
05760         if (!invalidationReason().isEmpty()) {
05761             return QDBusPendingReply<>(QDBusMessage::createError(
05762                 invalidationReason(),
05763                 invalidationMessage()
05764             ));
05765         }
05766 
05767         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05768                 this->staticInterfaceName(), QLatin1String("AddStatus"));
05769         callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
05770         return this->connection().asyncCall(callMessage, timeout);
05771     }
05772 
05786     inline QDBusPendingReply<> ClearStatus(int timeout = -1)
05787     {
05788         if (!invalidationReason().isEmpty()) {
05789             return QDBusPendingReply<>(QDBusMessage::createError(
05790                 invalidationReason(),
05791                 invalidationMessage()
05792             ));
05793         }
05794 
05795         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05796                 this->staticInterfaceName(), QLatin1String("ClearStatus"));
05797         return this->connection().asyncCall(callMessage, timeout);
05798     }
05799 
05823     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
05824     {
05825         if (!invalidationReason().isEmpty()) {
05826             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
05827                 invalidationReason(),
05828                 invalidationMessage()
05829             ));
05830         }
05831 
05832         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05833                 this->staticInterfaceName(), QLatin1String("GetPresence"));
05834         callMessage << QVariant::fromValue(contacts);
05835         return this->connection().asyncCall(callMessage, timeout);
05836     }
05837 
05859     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
05860     {
05861         if (!invalidationReason().isEmpty()) {
05862             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
05863                 invalidationReason(),
05864                 invalidationMessage()
05865             ));
05866         }
05867 
05868         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05869                 this->staticInterfaceName(), QLatin1String("GetStatuses"));
05870         return this->connection().asyncCall(callMessage, timeout);
05871     }
05872 
05891     inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
05892     {
05893         if (!invalidationReason().isEmpty()) {
05894             return QDBusPendingReply<>(QDBusMessage::createError(
05895                 invalidationReason(),
05896                 invalidationMessage()
05897             ));
05898         }
05899 
05900         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05901                 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
05902         callMessage << QVariant::fromValue(status);
05903         return this->connection().asyncCall(callMessage, timeout);
05904     }
05905 
05924     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
05925     {
05926         if (!invalidationReason().isEmpty()) {
05927             return QDBusPendingReply<>(QDBusMessage::createError(
05928                 invalidationReason(),
05929                 invalidationMessage()
05930             ));
05931         }
05932 
05933         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05934                 this->staticInterfaceName(), QLatin1String("RequestPresence"));
05935         callMessage << QVariant::fromValue(contacts);
05936         return this->connection().asyncCall(callMessage, timeout);
05937     }
05938 
05954     inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
05955     {
05956         if (!invalidationReason().isEmpty()) {
05957             return QDBusPendingReply<>(QDBusMessage::createError(
05958                 invalidationReason(),
05959                 invalidationMessage()
05960             ));
05961         }
05962 
05963         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05964                 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
05965         callMessage << QVariant::fromValue(time);
05966         return this->connection().asyncCall(callMessage, timeout);
05967     }
05968 
06004     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
06005     {
06006         if (!invalidationReason().isEmpty()) {
06007             return QDBusPendingReply<>(QDBusMessage::createError(
06008                 invalidationReason(),
06009                 invalidationMessage()
06010             ));
06011         }
06012 
06013         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06014                 this->staticInterfaceName(), QLatin1String("SetStatus"));
06015         callMessage << QVariant::fromValue(statuses);
06016         return this->connection().asyncCall(callMessage, timeout);
06017     }
06018 
06019 Q_SIGNALS:
06036     void PresenceUpdate(const Tp::ContactPresences& presence);
06037 
06038 protected:
06039     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06040 };
06041 
06049 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
06050 {
06051     Q_OBJECT
06052 
06053 public:
06060     static inline QLatin1String staticInterfaceName()
06061     {
06062         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
06063     }
06064 
06072     ConnectionInterfaceRequestsInterface(
06073         const QString& busName,
06074         const QString& objectPath,
06075         QObject* parent = 0
06076     );
06077 
06086     ConnectionInterfaceRequestsInterface(
06087         const QDBusConnection& connection,
06088         const QString& busName,
06089         const QString& objectPath,
06090         QObject* parent = 0
06091     );
06092 
06099     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
06100 
06108     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
06109 
06117     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06118 
06129     inline Tp::PendingVariant *requestPropertyChannels() const
06130     {
06131         return internalRequestProperty(QLatin1String("Channels"));
06132     }
06133 
06161     inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
06162     {
06163         return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
06164     }
06165 
06172     Tp::PendingVariantMap *requestAllProperties() const
06173     {
06174         return internalRequestAllProperties();
06175     }
06176 
06177 public Q_SLOTS:
06251     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
06252     {
06253         if (!invalidationReason().isEmpty()) {
06254             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06255                 invalidationReason(),
06256                 invalidationMessage()
06257             ));
06258         }
06259 
06260         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06261                 this->staticInterfaceName(), QLatin1String("CreateChannel"));
06262         callMessage << QVariant::fromValue(request);
06263         return this->connection().asyncCall(callMessage, timeout);
06264     }
06265 
06322     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
06323     {
06324         if (!invalidationReason().isEmpty()) {
06325             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
06326                 invalidationReason(),
06327                 invalidationMessage()
06328             ));
06329         }
06330 
06331         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06332                 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
06333         callMessage << QVariant::fromValue(request);
06334         return this->connection().asyncCall(callMessage, timeout);
06335     }
06336 
06337 Q_SIGNALS:
06379     void NewChannels(const Tp::ChannelDetailsList& channels);
06380 
06393     void ChannelClosed(const QDBusObjectPath& removed);
06394 
06395 protected:
06396     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06397 };
06398 
06406 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
06407 {
06408     Q_OBJECT
06409 
06410 public:
06417     static inline QLatin1String staticInterfaceName()
06418     {
06419         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
06420     }
06421 
06429     ConnectionInterfaceServicePointInterface(
06430         const QString& busName,
06431         const QString& objectPath,
06432         QObject* parent = 0
06433     );
06434 
06443     ConnectionInterfaceServicePointInterface(
06444         const QDBusConnection& connection,
06445         const QString& busName,
06446         const QString& objectPath,
06447         QObject* parent = 0
06448     );
06449 
06456     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
06457 
06465     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
06466 
06474     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06475 
06485     inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
06486     {
06487         return internalRequestProperty(QLatin1String("KnownServicePoints"));
06488     }
06489 
06496     Tp::PendingVariantMap *requestAllProperties() const
06497     {
06498         return internalRequestAllProperties();
06499     }
06500 
06501 Q_SIGNALS:
06513     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
06514 
06515 protected:
06516     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06517 };
06518 
06526 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
06527 {
06528     Q_OBJECT
06529 
06530 public:
06537     static inline QLatin1String staticInterfaceName()
06538     {
06539         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
06540     }
06541 
06549     ConnectionInterfaceSimplePresenceInterface(
06550         const QString& busName,
06551         const QString& objectPath,
06552         QObject* parent = 0
06553     );
06554 
06563     ConnectionInterfaceSimplePresenceInterface(
06564         const QDBusConnection& connection,
06565         const QString& busName,
06566         const QString& objectPath,
06567         QObject* parent = 0
06568     );
06569 
06576     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
06577 
06585     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06586 
06594     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06595 
06635     inline Tp::PendingVariant *requestPropertyStatuses() const
06636     {
06637         return internalRequestProperty(QLatin1String("Statuses"));
06638     }
06639 
06646     Tp::PendingVariantMap *requestAllProperties() const
06647     {
06648         return internalRequestAllProperties();
06649     }
06650 
06651 public Q_SLOTS:
06711     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
06712     {
06713         if (!invalidationReason().isEmpty()) {
06714             return QDBusPendingReply<>(QDBusMessage::createError(
06715                 invalidationReason(),
06716                 invalidationMessage()
06717             ));
06718         }
06719 
06720         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06721                 this->staticInterfaceName(), QLatin1String("SetPresence"));
06722         callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
06723         return this->connection().asyncCall(callMessage, timeout);
06724     }
06725 
06755     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
06756     {
06757         if (!invalidationReason().isEmpty()) {
06758             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
06759                 invalidationReason(),
06760                 invalidationMessage()
06761             ));
06762         }
06763 
06764         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06765                 this->staticInterfaceName(), QLatin1String("GetPresences"));
06766         callMessage << QVariant::fromValue(contacts);
06767         return this->connection().asyncCall(callMessage, timeout);
06768     }
06769 
06770 Q_SIGNALS:
06783     void PresencesChanged(const Tp::SimpleContactPresences& presence);
06784 
06785 protected:
06786     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06787 };
06788 }
06789 }
06790 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
06791 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
06792 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
06793 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
06794 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
06795 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
06796 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
06797 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
06798 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
06799 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
06800 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
06801 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
06802 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
06803 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
06804 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
06805 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
06806 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
06807 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
06808 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
06809 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


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