00001
00002
00003
00004
00005
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/Client/AbstractInterface>
00023 #include <TelepathyQt4/Client/DBusProxy>
00024
00025
00026 #ifndef TELEPATHY_GNUC_DEPRECATED
00027 # if defined(Q_CC_GNUC) && __GNUC__ >= 4
00028 # define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
00029 # else
00030 # define TELEPATHY_GNUC_DEPRECATED
00031 # endif
00032 #endif
00033 namespace Telepathy
00034 {
00035 namespace Client
00036 {
00037
00045 class ConnectionInterface : public Telepathy::Client::AbstractInterface
00046 {
00047 Q_OBJECT
00048
00049 public:
00056 static inline const char *staticInterfaceName()
00057 {
00058 return "org.freedesktop.Telepathy.Connection";
00059 }
00060
00068 ConnectionInterface(
00069 const QString& serviceName,
00070 const QString& objectPath,
00071 QObject* parent = 0
00072 );
00073
00082 ConnectionInterface(
00083 const QDBusConnection& connection,
00084 const QString& serviceName,
00085 const QString& objectPath,
00086 QObject* parent = 0
00087 );
00088
00095 ConnectionInterface(Telepathy::Client::DBusProxy *proxy);
00096
00106 Q_PROPERTY(uint SelfHandle READ SelfHandle)
00107
00108
00116 inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
00117 {
00118 return qvariant_cast<uint>(internalPropGet("SelfHandle"));
00119 }
00120
00121 public Q_SLOTS:
00129 inline QDBusPendingReply<> Connect()
00130 {
00131 if (!invalidationReason().isEmpty()) {
00132 return QDBusPendingReply<>(QDBusMessage::createError(
00133 invalidationReason(),
00134 invalidationMessage()
00135 ));
00136 }
00137
00138
00139 return asyncCall(QLatin1String("Connect"));
00140 }
00141
00149 inline QDBusPendingReply<> Disconnect()
00150 {
00151 if (!invalidationReason().isEmpty()) {
00152 return QDBusPendingReply<>(QDBusMessage::createError(
00153 invalidationReason(),
00154 invalidationMessage()
00155 ));
00156 }
00157
00158
00159 return asyncCall(QLatin1String("Disconnect"));
00160 }
00161
00191 inline QDBusPendingReply<QStringList> GetInterfaces()
00192 {
00193 if (!invalidationReason().isEmpty()) {
00194 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00195 invalidationReason(),
00196 invalidationMessage()
00197 ));
00198 }
00199
00200
00201 return asyncCall(QLatin1String("GetInterfaces"));
00202 }
00203
00213 inline QDBusPendingReply<QString> GetProtocol()
00214 {
00215 if (!invalidationReason().isEmpty()) {
00216 return QDBusPendingReply<QString>(QDBusMessage::createError(
00217 invalidationReason(),
00218 invalidationMessage()
00219 ));
00220 }
00221
00222
00223 return asyncCall(QLatin1String("GetProtocol"));
00224 }
00225
00236 inline QDBusPendingReply<uint> GetSelfHandle()
00237 {
00238 if (!invalidationReason().isEmpty()) {
00239 return QDBusPendingReply<uint>(QDBusMessage::createError(
00240 invalidationReason(),
00241 invalidationMessage()
00242 ));
00243 }
00244
00245
00246 return asyncCall(QLatin1String("GetSelfHandle"));
00247 }
00248
00258 inline QDBusPendingReply<uint> GetStatus()
00259 {
00260 if (!invalidationReason().isEmpty()) {
00261 return QDBusPendingReply<uint>(QDBusMessage::createError(
00262 invalidationReason(),
00263 invalidationMessage()
00264 ));
00265 }
00266
00267
00268 return asyncCall(QLatin1String("GetStatus"));
00269 }
00270
00300 inline QDBusPendingReply<> HoldHandles(uint handleType, const Telepathy::UIntList& handles)
00301 {
00302 if (!invalidationReason().isEmpty()) {
00303 return QDBusPendingReply<>(QDBusMessage::createError(
00304 invalidationReason(),
00305 invalidationMessage()
00306 ));
00307 }
00308
00309
00310 QList<QVariant> argumentList;
00311 argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00312 return asyncCallWithArgumentList(QLatin1String("HoldHandles"), argumentList);
00313 }
00314
00332 inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Telepathy::UIntList& handles)
00333 {
00334 if (!invalidationReason().isEmpty()) {
00335 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00336 invalidationReason(),
00337 invalidationMessage()
00338 ));
00339 }
00340
00341
00342 QList<QVariant> argumentList;
00343 argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00344 return asyncCallWithArgumentList(QLatin1String("InspectHandles"), argumentList);
00345 }
00346
00356 inline QDBusPendingReply<Telepathy::ChannelInfoList> ListChannels()
00357 {
00358 if (!invalidationReason().isEmpty()) {
00359 return QDBusPendingReply<Telepathy::ChannelInfoList>(QDBusMessage::createError(
00360 invalidationReason(),
00361 invalidationMessage()
00362 ));
00363 }
00364
00365
00366 return asyncCall(QLatin1String("ListChannels"));
00367 }
00368
00385 inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Telepathy::UIntList& handles)
00386 {
00387 if (!invalidationReason().isEmpty()) {
00388 return QDBusPendingReply<>(QDBusMessage::createError(
00389 invalidationReason(),
00390 invalidationMessage()
00391 ));
00392 }
00393
00394
00395 QList<QVariant> argumentList;
00396 argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00397 return asyncCallWithArgumentList(QLatin1String("ReleaseHandles"), argumentList);
00398 }
00399
00472 inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler)
00473 {
00474 if (!invalidationReason().isEmpty()) {
00475 return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00476 invalidationReason(),
00477 invalidationMessage()
00478 ));
00479 }
00480
00481
00482 QList<QVariant> argumentList;
00483 argumentList << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00484 return asyncCallWithArgumentList(QLatin1String("RequestChannel"), argumentList);
00485 }
00486
00512 inline QDBusPendingReply<Telepathy::UIntList> RequestHandles(uint handleType, const QStringList& names)
00513 {
00514 if (!invalidationReason().isEmpty()) {
00515 return QDBusPendingReply<Telepathy::UIntList>(QDBusMessage::createError(
00516 invalidationReason(),
00517 invalidationMessage()
00518 ));
00519 }
00520
00521
00522 QList<QVariant> argumentList;
00523 argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(names);
00524 return asyncCallWithArgumentList(QLatin1String("RequestHandles"), argumentList);
00525 }
00526
00527 Q_SIGNALS:
00539 void SelfHandleChanged(uint selfHandle);
00540
00582 void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00583
00645 void ConnectionError(const QString& error, const QVariantMap& details);
00646
00663 void StatusChanged(uint status, uint reason);
00664
00665 protected:
00666 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
00667 };
00668
00676 class ConnectionInterfaceAliasingInterface : public Telepathy::Client::AbstractInterface
00677 {
00678 Q_OBJECT
00679
00680 public:
00687 static inline const char *staticInterfaceName()
00688 {
00689 return "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
00690 }
00691
00699 ConnectionInterfaceAliasingInterface(
00700 const QString& serviceName,
00701 const QString& objectPath,
00702 QObject* parent = 0
00703 );
00704
00713 ConnectionInterfaceAliasingInterface(
00714 const QDBusConnection& connection,
00715 const QString& serviceName,
00716 const QString& objectPath,
00717 QObject* parent = 0
00718 );
00719
00726 ConnectionInterfaceAliasingInterface(Telepathy::Client::DBusProxy *proxy);
00727
00735 explicit ConnectionInterfaceAliasingInterface(const Telepathy::Client::ConnectionInterface& mainInterface);
00736
00744 ConnectionInterfaceAliasingInterface(const Telepathy::Client::ConnectionInterface& mainInterface, QObject* parent);
00745
00746 public Q_SLOTS:
00757 inline QDBusPendingReply<uint> GetAliasFlags()
00758 {
00759 if (!invalidationReason().isEmpty()) {
00760 return QDBusPendingReply<uint>(QDBusMessage::createError(
00761 invalidationReason(),
00762 invalidationMessage()
00763 ));
00764 }
00765
00766
00767 return asyncCall(QLatin1String("GetAliasFlags"));
00768 }
00769
00783 inline QDBusPendingReply<QStringList> RequestAliases(const Telepathy::UIntList& contacts)
00784 {
00785 if (!invalidationReason().isEmpty()) {
00786 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00787 invalidationReason(),
00788 invalidationMessage()
00789 ));
00790 }
00791
00792
00793 QList<QVariant> argumentList;
00794 argumentList << QVariant::fromValue(contacts);
00795 return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
00796 }
00797
00814 inline QDBusPendingReply<Telepathy::AliasMap> GetAliases(const Telepathy::UIntList& contacts)
00815 {
00816 if (!invalidationReason().isEmpty()) {
00817 return QDBusPendingReply<Telepathy::AliasMap>(QDBusMessage::createError(
00818 invalidationReason(),
00819 invalidationMessage()
00820 ));
00821 }
00822
00823
00824 QList<QVariant> argumentList;
00825 argumentList << QVariant::fromValue(contacts);
00826 return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
00827 }
00828
00843 inline QDBusPendingReply<> SetAliases(const Telepathy::AliasMap& aliases)
00844 {
00845 if (!invalidationReason().isEmpty()) {
00846 return QDBusPendingReply<>(QDBusMessage::createError(
00847 invalidationReason(),
00848 invalidationMessage()
00849 ));
00850 }
00851
00852
00853 QList<QVariant> argumentList;
00854 argumentList << QVariant::fromValue(aliases);
00855 return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
00856 }
00857
00858 Q_SIGNALS:
00873 void AliasesChanged(const Telepathy::AliasPairList& aliases);
00874
00875 protected:
00876 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
00877 };
00878
00886 class ConnectionInterfaceAvatarsInterface : public Telepathy::Client::AbstractInterface
00887 {
00888 Q_OBJECT
00889
00890 public:
00897 static inline const char *staticInterfaceName()
00898 {
00899 return "org.freedesktop.Telepathy.Connection.Interface.Avatars";
00900 }
00901
00909 ConnectionInterfaceAvatarsInterface(
00910 const QString& serviceName,
00911 const QString& objectPath,
00912 QObject* parent = 0
00913 );
00914
00923 ConnectionInterfaceAvatarsInterface(
00924 const QDBusConnection& connection,
00925 const QString& serviceName,
00926 const QString& objectPath,
00927 QObject* parent = 0
00928 );
00929
00936 ConnectionInterfaceAvatarsInterface(Telepathy::Client::DBusProxy *proxy);
00937
00945 explicit ConnectionInterfaceAvatarsInterface(const Telepathy::Client::ConnectionInterface& mainInterface);
00946
00954 ConnectionInterfaceAvatarsInterface(const Telepathy::Client::ConnectionInterface& mainInterface, QObject* parent);
00955
00956 public Q_SLOTS:
00986 inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
00987 {
00988 if (!invalidationReason().isEmpty()) {
00989 return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
00990 invalidationReason(),
00991 invalidationMessage()
00992 ));
00993 }
00994
00995
00996 return asyncCall(QLatin1String("GetAvatarRequirements"));
00997 }
00998
01015 inline QDBusPendingReply<QStringList> GetAvatarTokens(const Telepathy::UIntList& contacts)
01016 {
01017 if (!invalidationReason().isEmpty()) {
01018 return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01019 invalidationReason(),
01020 invalidationMessage()
01021 ));
01022 }
01023
01024
01025 QList<QVariant> argumentList;
01026 argumentList << QVariant::fromValue(contacts);
01027 return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
01028 }
01029
01052 inline QDBusPendingReply<Telepathy::AvatarTokenMap> GetKnownAvatarTokens(const Telepathy::UIntList& contacts)
01053 {
01054 if (!invalidationReason().isEmpty()) {
01055 return QDBusPendingReply<Telepathy::AvatarTokenMap>(QDBusMessage::createError(
01056 invalidationReason(),
01057 invalidationMessage()
01058 ));
01059 }
01060
01061
01062 QList<QVariant> argumentList;
01063 argumentList << QVariant::fromValue(contacts);
01064 return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
01065 }
01066
01086 inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
01087 {
01088 if (!invalidationReason().isEmpty()) {
01089 return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01090 invalidationReason(),
01091 invalidationMessage()
01092 ));
01093 }
01094
01095
01096 QList<QVariant> argumentList;
01097 argumentList << QVariant::fromValue(contact);
01098 return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
01099 }
01100
01114 inline QDBusPendingReply<> RequestAvatars(const Telepathy::UIntList& contacts)
01115 {
01116 if (!invalidationReason().isEmpty()) {
01117 return QDBusPendingReply<>(QDBusMessage::createError(
01118 invalidationReason(),
01119 invalidationMessage()
01120 ));
01121 }
01122
01123
01124 QList<QVariant> argumentList;
01125 argumentList << QVariant::fromValue(contacts);
01126 return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
01127 }
01128
01147 inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
01148 {
01149 if (!invalidationReason().isEmpty()) {
01150 return QDBusPendingReply<QString>(QDBusMessage::createError(
01151 invalidationReason(),
01152 invalidationMessage()
01153 ));
01154 }
01155
01156
01157 QList<QVariant> argumentList;
01158 argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01159 return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
01160 }
01161
01167 inline QDBusPendingReply<> ClearAvatar()
01168 {
01169 if (!invalidationReason().isEmpty()) {
01170 return QDBusPendingReply<>(QDBusMessage::createError(
01171 invalidationReason(),
01172 invalidationMessage()
01173 ));
01174 }
01175
01176
01177 return asyncCall(QLatin1String("ClearAvatar"));
01178 }
01179
01180 Q_SIGNALS:
01197 void AvatarUpdated(uint contact, const QString& newAvatarToken);
01198
01221 void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01222
01223 protected:
01224 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
01225 };
01226
01234 class ConnectionInterfaceCapabilitiesInterface : public Telepathy::Client::AbstractInterface
01235 {
01236 Q_OBJECT
01237
01238 public:
01245 static inline const char *staticInterfaceName()
01246 {
01247 return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
01248 }
01249
01257 ConnectionInterfaceCapabilitiesInterface(
01258 const QString& serviceName,
01259 const QString& objectPath,
01260 QObject* parent = 0
01261 );
01262
01271 ConnectionInterfaceCapabilitiesInterface(
01272 const QDBusConnection& connection,
01273 const QString& serviceName,
01274 const QString& objectPath,
01275 QObject* parent = 0
01276 );
01277
01284 ConnectionInterfaceCapabilitiesInterface(Telepathy::Client::DBusProxy *proxy);
01285
01293 explicit ConnectionInterfaceCapabilitiesInterface(const Telepathy::Client::ConnectionInterface& mainInterface);
01294
01302 ConnectionInterfaceCapabilitiesInterface(const Telepathy::Client::ConnectionInterface& mainInterface, QObject* parent);
01303
01304 public Q_SLOTS:
01345 inline QDBusPendingReply<Telepathy::CapabilityPairList> AdvertiseCapabilities(const Telepathy::CapabilityPairList& add, const QStringList& remove)
01346 {
01347 if (!invalidationReason().isEmpty()) {
01348 return QDBusPendingReply<Telepathy::CapabilityPairList>(QDBusMessage::createError(
01349 invalidationReason(),
01350 invalidationMessage()
01351 ));
01352 }
01353
01354
01355 QList<QVariant> argumentList;
01356 argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
01357 return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
01358 }
01359
01385 inline QDBusPendingReply<Telepathy::ContactCapabilityList> GetCapabilities(const Telepathy::UIntList& handles)
01386 {
01387 if (!invalidationReason().isEmpty()) {
01388 return QDBusPendingReply<Telepathy::ContactCapabilityList>(QDBusMessage::createError(
01389 invalidationReason(),
01390 invalidationMessage()
01391 ));
01392 }
01393
01394
01395 QList<QVariant> argumentList;
01396 argumentList << QVariant::fromValue(handles);
01397 return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
01398 }
01399
01400 Q_SIGNALS:
01423 void CapabilitiesChanged(const Telepathy::CapabilityChangeList& caps);
01424
01425 protected:
01426 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
01427 };
01428
01436 class ConnectionInterfaceContactsInterface : public Telepathy::Client::AbstractInterface
01437 {
01438 Q_OBJECT
01439
01440 public:
01447 static inline const char *staticInterfaceName()
01448 {
01449 return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
01450 }
01451
01459 ConnectionInterfaceContactsInterface(
01460 const QString& serviceName,
01461 const QString& objectPath,
01462 QObject* parent = 0
01463 );
01464
01473 ConnectionInterfaceContactsInterface(
01474 const QDBusConnection& connection,
01475 const QString& serviceName,
01476 const QString& objectPath,
01477 QObject* parent = 0
01478 );
01479
01486 ConnectionInterfaceContactsInterface(Telepathy::Client::DBusProxy *proxy);
01487
01495 explicit ConnectionInterfaceContactsInterface(const Telepathy::Client::ConnectionInterface& mainInterface);
01496
01504 ConnectionInterfaceContactsInterface(const Telepathy::Client::ConnectionInterface& mainInterface, QObject* parent);
01505
01512 Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
01513
01514
01522 inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
01523 {
01524 return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
01525 }
01526
01527 public Q_SLOTS:
01591 inline QDBusPendingReply<Telepathy::ContactAttributesMap> GetContactAttributes(const Telepathy::UIntList& handles, const QStringList& interfaces, bool hold)
01592 {
01593 if (!invalidationReason().isEmpty()) {
01594 return QDBusPendingReply<Telepathy::ContactAttributesMap>(QDBusMessage::createError(
01595 invalidationReason(),
01596 invalidationMessage()
01597 ));
01598 }
01599
01600
01601 QList<QVariant> argumentList;
01602 argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
01603 return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
01604 }
01605
01606 protected:
01607 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
01608 };
01609
01617 class ConnectionInterfacePresenceInterface : public Telepathy::Client::AbstractInterface
01618 {
01619 Q_OBJECT
01620
01621 public:
01628 static inline const char *staticInterfaceName()
01629 {
01630 return "org.freedesktop.Telepathy.Connection.Interface.Presence";
01631 }
01632
01640 ConnectionInterfacePresenceInterface(
01641 const QString& serviceName,
01642 const QString& objectPath,
01643 QObject* parent = 0
01644 );
01645
01654 ConnectionInterfacePresenceInterface(
01655 const QDBusConnection& connection,
01656 const QString& serviceName,
01657 const QString& objectPath,
01658 QObject* parent = 0
01659 );
01660
01667 ConnectionInterfacePresenceInterface(Telepathy::Client::DBusProxy *proxy);
01668
01676 explicit ConnectionInterfacePresenceInterface(const Telepathy::Client::ConnectionInterface& mainInterface);
01677
01685 ConnectionInterfacePresenceInterface(const Telepathy::Client::ConnectionInterface& mainInterface, QObject* parent);
01686
01687 public Q_SLOTS:
01704 inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
01705 {
01706 if (!invalidationReason().isEmpty()) {
01707 return QDBusPendingReply<>(QDBusMessage::createError(
01708 invalidationReason(),
01709 invalidationMessage()
01710 ));
01711 }
01712
01713
01714 QList<QVariant> argumentList;
01715 argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
01716 return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
01717 }
01718
01727 inline QDBusPendingReply<> ClearStatus()
01728 {
01729 if (!invalidationReason().isEmpty()) {
01730 return QDBusPendingReply<>(QDBusMessage::createError(
01731 invalidationReason(),
01732 invalidationMessage()
01733 ));
01734 }
01735
01736
01737 return asyncCall(QLatin1String("ClearStatus"));
01738 }
01739
01758 inline QDBusPendingReply<Telepathy::ContactPresences> GetPresence(const Telepathy::UIntList& contacts)
01759 {
01760 if (!invalidationReason().isEmpty()) {
01761 return QDBusPendingReply<Telepathy::ContactPresences>(QDBusMessage::createError(
01762 invalidationReason(),
01763 invalidationMessage()
01764 ));
01765 }
01766
01767
01768 QList<QVariant> argumentList;
01769 argumentList << QVariant::fromValue(contacts);
01770 return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
01771 }
01772
01789 inline QDBusPendingReply<Telepathy::StatusSpecMap> GetStatuses()
01790 {
01791 if (!invalidationReason().isEmpty()) {
01792 return QDBusPendingReply<Telepathy::StatusSpecMap>(QDBusMessage::createError(
01793 invalidationReason(),
01794 invalidationMessage()
01795 ));
01796 }
01797
01798
01799 return asyncCall(QLatin1String("GetStatuses"));
01800 }
01801
01815 inline QDBusPendingReply<> RemoveStatus(const QString& status)
01816 {
01817 if (!invalidationReason().isEmpty()) {
01818 return QDBusPendingReply<>(QDBusMessage::createError(
01819 invalidationReason(),
01820 invalidationMessage()
01821 ));
01822 }
01823
01824
01825 QList<QVariant> argumentList;
01826 argumentList << QVariant::fromValue(status);
01827 return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
01828 }
01829
01843 inline QDBusPendingReply<> RequestPresence(const Telepathy::UIntList& contacts)
01844 {
01845 if (!invalidationReason().isEmpty()) {
01846 return QDBusPendingReply<>(QDBusMessage::createError(
01847 invalidationReason(),
01848 invalidationMessage()
01849 ));
01850 }
01851
01852
01853 QList<QVariant> argumentList;
01854 argumentList << QVariant::fromValue(contacts);
01855 return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
01856 }
01857
01868 inline QDBusPendingReply<> SetLastActivityTime(uint time)
01869 {
01870 if (!invalidationReason().isEmpty()) {
01871 return QDBusPendingReply<>(QDBusMessage::createError(
01872 invalidationReason(),
01873 invalidationMessage()
01874 ));
01875 }
01876
01877
01878 QList<QVariant> argumentList;
01879 argumentList << QVariant::fromValue(time);
01880 return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
01881 }
01882
01900 inline QDBusPendingReply<> SetStatus(const Telepathy::MultipleStatusMap& statuses)
01901 {
01902 if (!invalidationReason().isEmpty()) {
01903 return QDBusPendingReply<>(QDBusMessage::createError(
01904 invalidationReason(),
01905 invalidationMessage()
01906 ));
01907 }
01908
01909
01910 QList<QVariant> argumentList;
01911 argumentList << QVariant::fromValue(statuses);
01912 return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
01913 }
01914
01915 Q_SIGNALS:
01932 void PresenceUpdate(const Telepathy::ContactPresences& presence);
01933
01934 protected:
01935 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
01936 };
01937
01945 class ConnectionInterfaceRequestsInterface : public Telepathy::Client::AbstractInterface
01946 {
01947 Q_OBJECT
01948
01949 public:
01956 static inline const char *staticInterfaceName()
01957 {
01958 return "org.freedesktop.Telepathy.Connection.Interface.Requests";
01959 }
01960
01968 ConnectionInterfaceRequestsInterface(
01969 const QString& serviceName,
01970 const QString& objectPath,
01971 QObject* parent = 0
01972 );
01973
01982 ConnectionInterfaceRequestsInterface(
01983 const QDBusConnection& connection,
01984 const QString& serviceName,
01985 const QString& objectPath,
01986 QObject* parent = 0
01987 );
01988
01995 ConnectionInterfaceRequestsInterface(Telepathy::Client::DBusProxy *proxy);
01996
02004 explicit ConnectionInterfaceRequestsInterface(const Telepathy::Client::ConnectionInterface& mainInterface);
02005
02013 ConnectionInterfaceRequestsInterface(const Telepathy::Client::ConnectionInterface& mainInterface, QObject* parent);
02014
02021 Q_PROPERTY(Telepathy::ChannelDetailsList Channels READ Channels)
02022
02023
02031 inline Telepathy::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
02032 {
02033 return qvariant_cast<Telepathy::ChannelDetailsList>(internalPropGet("Channels"));
02034 }
02035
02059 Q_PROPERTY(Telepathy::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
02060
02061
02069 inline Telepathy::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
02070 {
02071 return qvariant_cast<Telepathy::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
02072 }
02073
02074 public Q_SLOTS:
02143 inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
02144 {
02145 if (!invalidationReason().isEmpty()) {
02146 return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
02147 invalidationReason(),
02148 invalidationMessage()
02149 ));
02150 }
02151
02152
02153 QList<QVariant> argumentList;
02154 argumentList << QVariant::fromValue(request);
02155 return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
02156 }
02157
02209 inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
02210 {
02211 if (!invalidationReason().isEmpty()) {
02212 return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
02213 invalidationReason(),
02214 invalidationMessage()
02215 ));
02216 }
02217
02218
02219 QList<QVariant> argumentList;
02220 argumentList << QVariant::fromValue(request);
02221 return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
02222 }
02223
02224 Q_SIGNALS:
02266 void NewChannels(const Telepathy::ChannelDetailsList& channels);
02267
02280 void ChannelClosed(const QDBusObjectPath& removed);
02281
02282 protected:
02283 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
02284 };
02285
02293 class ConnectionInterfaceSimplePresenceInterface : public Telepathy::Client::AbstractInterface
02294 {
02295 Q_OBJECT
02296
02297 public:
02304 static inline const char *staticInterfaceName()
02305 {
02306 return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
02307 }
02308
02316 ConnectionInterfaceSimplePresenceInterface(
02317 const QString& serviceName,
02318 const QString& objectPath,
02319 QObject* parent = 0
02320 );
02321
02330 ConnectionInterfaceSimplePresenceInterface(
02331 const QDBusConnection& connection,
02332 const QString& serviceName,
02333 const QString& objectPath,
02334 QObject* parent = 0
02335 );
02336
02343 ConnectionInterfaceSimplePresenceInterface(Telepathy::Client::DBusProxy *proxy);
02344
02352 explicit ConnectionInterfaceSimplePresenceInterface(const Telepathy::Client::ConnectionInterface& mainInterface);
02353
02361 ConnectionInterfaceSimplePresenceInterface(const Telepathy::Client::ConnectionInterface& mainInterface, QObject* parent);
02362
02398 Q_PROPERTY(Telepathy::SimpleStatusSpecMap Statuses READ Statuses)
02399
02400
02408 inline Telepathy::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
02409 {
02410 return qvariant_cast<Telepathy::SimpleStatusSpecMap>(internalPropGet("Statuses"));
02411 }
02412
02413 public Q_SLOTS:
02459 inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
02460 {
02461 if (!invalidationReason().isEmpty()) {
02462 return QDBusPendingReply<>(QDBusMessage::createError(
02463 invalidationReason(),
02464 invalidationMessage()
02465 ));
02466 }
02467
02468
02469 QList<QVariant> argumentList;
02470 argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
02471 return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
02472 }
02473
02498 inline QDBusPendingReply<Telepathy::SimpleContactPresences> GetPresences(const Telepathy::UIntList& contacts)
02499 {
02500 if (!invalidationReason().isEmpty()) {
02501 return QDBusPendingReply<Telepathy::SimpleContactPresences>(QDBusMessage::createError(
02502 invalidationReason(),
02503 invalidationMessage()
02504 ));
02505 }
02506
02507
02508 QList<QVariant> argumentList;
02509 argumentList << QVariant::fromValue(contacts);
02510 return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
02511 }
02512
02513 Q_SIGNALS:
02526 void PresencesChanged(const Telepathy::SimpleContactPresences& presence);
02527
02528 protected:
02529 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
02530 };
02531 }
02532 }