Home · All Classes · All Namespaces · Modules · Functions · Files

cli-channel.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 
00025 // basically the same as GLib's G_GNUC_DEPRECATED
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 Tp
00034 {
00035 namespace Client
00036 {
00037 
00045 class ChannelInterface : public Tp::AbstractInterface
00046 {
00047     Q_OBJECT
00048 
00049 public:
00056     static inline const char *staticInterfaceName()
00057     {
00058         return "org.freedesktop.Telepathy.Channel";
00059     }
00060 
00068     ChannelInterface(
00069         const QString& busName,
00070         const QString& objectPath,
00071         QObject* parent = 0
00072     );
00073 
00082     ChannelInterface(
00083         const QDBusConnection& connection,
00084         const QString& busName,
00085         const QString& objectPath,
00086         QObject* parent = 0
00087     );
00088 
00095     ChannelInterface(Tp::DBusProxy *proxy);
00096 
00121     Q_PROPERTY(QString ChannelType READ ChannelType)
00122 
00123     
00131     inline QString ChannelType() const TELEPATHY_GNUC_DEPRECATED
00132     {
00133         return qvariant_cast<QString>(internalPropGet("ChannelType"));
00134     }
00135 
00163     Q_PROPERTY(QStringList Interfaces READ Interfaces)
00164 
00165     
00173     inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
00174     {
00175         return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
00176     }
00177 
00214     Q_PROPERTY(uint TargetHandle READ TargetHandle)
00215 
00216     
00224     inline uint TargetHandle() const TELEPATHY_GNUC_DEPRECATED
00225     {
00226         return qvariant_cast<uint>(internalPropGet("TargetHandle"));
00227     }
00228 
00273     Q_PROPERTY(QString TargetID READ TargetID)
00274 
00275     
00283     inline QString TargetID() const TELEPATHY_GNUC_DEPRECATED
00284     {
00285         return qvariant_cast<QString>(internalPropGet("TargetID"));
00286     }
00287 
00301     Q_PROPERTY(uint TargetHandleType READ TargetHandleType)
00302 
00303     
00311     inline uint TargetHandleType() const TELEPATHY_GNUC_DEPRECATED
00312     {
00313         return qvariant_cast<uint>(internalPropGet("TargetHandleType"));
00314     }
00315 
00378     Q_PROPERTY(bool Requested READ Requested)
00379 
00380     
00388     inline bool Requested() const TELEPATHY_GNUC_DEPRECATED
00389     {
00390         return qvariant_cast<bool>(internalPropGet("Requested"));
00391     }
00392 
00426     Q_PROPERTY(uint InitiatorHandle READ InitiatorHandle)
00427 
00428     
00436     inline uint InitiatorHandle() const TELEPATHY_GNUC_DEPRECATED
00437     {
00438         return qvariant_cast<uint>(internalPropGet("InitiatorHandle"));
00439     }
00440 
00469     Q_PROPERTY(QString InitiatorID READ InitiatorID)
00470 
00471     
00479     inline QString InitiatorID() const TELEPATHY_GNUC_DEPRECATED
00480     {
00481         return qvariant_cast<QString>(internalPropGet("InitiatorID"));
00482     }
00483 
00484 public Q_SLOTS:
00494     inline QDBusPendingReply<> Close()
00495     {
00496         if (!invalidationReason().isEmpty()) {
00497             return QDBusPendingReply<>(QDBusMessage::createError(
00498                 invalidationReason(),
00499                 invalidationMessage()
00500             ));
00501         }
00502 
00503 
00504         return asyncCall(QLatin1String("Close"));
00505     }
00506 
00519     inline QDBusPendingReply<QString> GetChannelType()
00520     {
00521         if (!invalidationReason().isEmpty()) {
00522             return QDBusPendingReply<QString>(QDBusMessage::createError(
00523                 invalidationReason(),
00524                 invalidationMessage()
00525             ));
00526         }
00527 
00528 
00529         return asyncCall(QLatin1String("GetChannelType"));
00530     }
00531 
00550     inline QDBusPendingReply<uint, uint> GetHandle()
00551     {
00552         if (!invalidationReason().isEmpty()) {
00553             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00554                 invalidationReason(),
00555                 invalidationMessage()
00556             ));
00557         }
00558 
00559 
00560         return asyncCall(QLatin1String("GetHandle"));
00561     }
00562 
00575     inline QDBusPendingReply<QStringList> GetInterfaces()
00576     {
00577         if (!invalidationReason().isEmpty()) {
00578             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00579                 invalidationReason(),
00580                 invalidationMessage()
00581             ));
00582         }
00583 
00584 
00585         return asyncCall(QLatin1String("GetInterfaces"));
00586     }
00587 
00588 Q_SIGNALS:
00596     void Closed();
00597 
00598 protected:
00599     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00600 };
00601 
00609 class ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00610 {
00611     Q_OBJECT
00612 
00613 public:
00620     static inline const char *staticInterfaceName()
00621     {
00622         return "org.freedesktop.Telepathy.Channel.Interface.CallState";
00623     }
00624 
00632     ChannelInterfaceCallStateInterface(
00633         const QString& busName,
00634         const QString& objectPath,
00635         QObject* parent = 0
00636     );
00637 
00646     ChannelInterfaceCallStateInterface(
00647         const QDBusConnection& connection,
00648         const QString& busName,
00649         const QString& objectPath,
00650         QObject* parent = 0
00651     );
00652 
00659     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00660 
00668     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00669 
00677     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00678 
00679 public Q_SLOTS:
00690     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
00691     {
00692         if (!invalidationReason().isEmpty()) {
00693             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00694                 invalidationReason(),
00695                 invalidationMessage()
00696             ));
00697         }
00698 
00699 
00700         return asyncCall(QLatin1String("GetCallStates"));
00701     }
00702 
00703 Q_SIGNALS:
00717     void CallStateChanged(uint contact, uint state);
00718 
00719 protected:
00720     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00721 };
00722 
00730 class ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00731 {
00732     Q_OBJECT
00733 
00734 public:
00741     static inline const char *staticInterfaceName()
00742     {
00743         return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
00744     }
00745 
00753     ChannelInterfaceChatStateInterface(
00754         const QString& busName,
00755         const QString& objectPath,
00756         QObject* parent = 0
00757     );
00758 
00767     ChannelInterfaceChatStateInterface(
00768         const QDBusConnection& connection,
00769         const QString& busName,
00770         const QString& objectPath,
00771         QObject* parent = 0
00772     );
00773 
00780     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00781 
00789     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00790 
00798     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00799 
00800 public Q_SLOTS:
00811     inline QDBusPendingReply<> SetChatState(uint state)
00812     {
00813         if (!invalidationReason().isEmpty()) {
00814             return QDBusPendingReply<>(QDBusMessage::createError(
00815                 invalidationReason(),
00816                 invalidationMessage()
00817             ));
00818         }
00819 
00820 
00821         QList<QVariant> argumentList;
00822         argumentList << QVariant::fromValue(state);
00823         return asyncCallWithArgumentList(QLatin1String("SetChatState"), argumentList);
00824     }
00825 
00826 Q_SIGNALS:
00841     void ChatStateChanged(uint contact, uint state);
00842 
00843 protected:
00844     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00845 };
00846 
00854 class ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
00855 {
00856     Q_OBJECT
00857 
00858 public:
00865     static inline const char *staticInterfaceName()
00866     {
00867         return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
00868     }
00869 
00877     ChannelInterfaceDTMFInterface(
00878         const QString& busName,
00879         const QString& objectPath,
00880         QObject* parent = 0
00881     );
00882 
00891     ChannelInterfaceDTMFInterface(
00892         const QDBusConnection& connection,
00893         const QString& busName,
00894         const QString& objectPath,
00895         QObject* parent = 0
00896     );
00897 
00904     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
00905 
00913     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
00914 
00922     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00923 
00924 public Q_SLOTS:
00942     inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
00943     {
00944         if (!invalidationReason().isEmpty()) {
00945             return QDBusPendingReply<>(QDBusMessage::createError(
00946                 invalidationReason(),
00947                 invalidationMessage()
00948             ));
00949         }
00950 
00951 
00952         QList<QVariant> argumentList;
00953         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
00954         return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
00955     }
00956 
00967     inline QDBusPendingReply<> StopTone(uint streamID)
00968     {
00969         if (!invalidationReason().isEmpty()) {
00970             return QDBusPendingReply<>(QDBusMessage::createError(
00971                 invalidationReason(),
00972                 invalidationMessage()
00973             ));
00974         }
00975 
00976 
00977         QList<QVariant> argumentList;
00978         argumentList << QVariant::fromValue(streamID);
00979         return asyncCallWithArgumentList(QLatin1String("StopTone"), argumentList);
00980     }
00981 
00982 protected:
00983     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00984 };
00985 
00993 class ChannelInterfaceGroupInterface : public Tp::AbstractInterface
00994 {
00995     Q_OBJECT
00996 
00997 public:
01004     static inline const char *staticInterfaceName()
01005     {
01006         return "org.freedesktop.Telepathy.Channel.Interface.Group";
01007     }
01008 
01016     ChannelInterfaceGroupInterface(
01017         const QString& busName,
01018         const QString& objectPath,
01019         QObject* parent = 0
01020     );
01021 
01030     ChannelInterfaceGroupInterface(
01031         const QDBusConnection& connection,
01032         const QString& busName,
01033         const QString& objectPath,
01034         QObject* parent = 0
01035     );
01036 
01043     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01044 
01052     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01053 
01061     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01062 
01071     Q_PROPERTY(uint GroupFlags READ GroupFlags)
01072 
01073     
01081     inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
01082     {
01083         return qvariant_cast<uint>(internalPropGet("GroupFlags"));
01084     }
01085 
01097     Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)
01098 
01099     
01107     inline Tp::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
01108     {
01109         return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
01110     }
01111 
01118     Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
01119 
01120     
01128     inline Tp::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
01129     {
01130         return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
01131     }
01132 
01138     Q_PROPERTY(Tp::UIntList Members READ Members)
01139 
01140     
01148     inline Tp::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
01149     {
01150         return qvariant_cast<Tp::UIntList>(internalPropGet("Members"));
01151     }
01152 
01159     Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)
01160 
01161     
01169     inline Tp::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
01170     {
01171         return qvariant_cast<Tp::UIntList>(internalPropGet("RemotePendingMembers"));
01172     }
01173 
01184     Q_PROPERTY(uint SelfHandle READ SelfHandle)
01185 
01186     
01194     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
01195     {
01196         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
01197     }
01198 
01199 public Q_SLOTS:
01223     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message)
01224     {
01225         if (!invalidationReason().isEmpty()) {
01226             return QDBusPendingReply<>(QDBusMessage::createError(
01227                 invalidationReason(),
01228                 invalidationMessage()
01229             ));
01230         }
01231 
01232 
01233         QList<QVariant> argumentList;
01234         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01235         return asyncCallWithArgumentList(QLatin1String("AddMembers"), argumentList);
01236     }
01237 
01255     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers()
01256     {
01257         if (!invalidationReason().isEmpty()) {
01258             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
01259                 invalidationReason(),
01260                 invalidationMessage()
01261             ));
01262         }
01263 
01264 
01265         return asyncCall(QLatin1String("GetAllMembers"));
01266     }
01267 
01277     inline QDBusPendingReply<uint> GetGroupFlags()
01278     {
01279         if (!invalidationReason().isEmpty()) {
01280             return QDBusPendingReply<uint>(QDBusMessage::createError(
01281                 invalidationReason(),
01282                 invalidationMessage()
01283             ));
01284         }
01285 
01286 
01287         return asyncCall(QLatin1String("GetGroupFlags"));
01288     }
01289 
01310     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles)
01311     {
01312         if (!invalidationReason().isEmpty()) {
01313             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01314                 invalidationReason(),
01315                 invalidationMessage()
01316             ));
01317         }
01318 
01319 
01320         QList<QVariant> argumentList;
01321         argumentList << QVariant::fromValue(handles);
01322         return asyncCallWithArgumentList(QLatin1String("GetHandleOwners"), argumentList);
01323     }
01324 
01331     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
01332     {
01333         if (!invalidationReason().isEmpty()) {
01334             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01335                 invalidationReason(),
01336                 invalidationMessage()
01337             ));
01338         }
01339 
01340 
01341         return asyncCall(QLatin1String("GetLocalPendingMembers"));
01342     }
01343 
01357     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
01358     {
01359         if (!invalidationReason().isEmpty()) {
01360             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
01361                 invalidationReason(),
01362                 invalidationMessage()
01363             ));
01364         }
01365 
01366 
01367         return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
01368     }
01369 
01375     inline QDBusPendingReply<Tp::UIntList> GetMembers()
01376     {
01377         if (!invalidationReason().isEmpty()) {
01378             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01379                 invalidationReason(),
01380                 invalidationMessage()
01381             ));
01382         }
01383 
01384 
01385         return asyncCall(QLatin1String("GetMembers"));
01386     }
01387 
01394     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
01395     {
01396         if (!invalidationReason().isEmpty()) {
01397             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01398                 invalidationReason(),
01399                 invalidationMessage()
01400             ));
01401         }
01402 
01403 
01404         return asyncCall(QLatin1String("GetRemotePendingMembers"));
01405     }
01406 
01412     inline QDBusPendingReply<uint> GetSelfHandle()
01413     {
01414         if (!invalidationReason().isEmpty()) {
01415             return QDBusPendingReply<uint>(QDBusMessage::createError(
01416                 invalidationReason(),
01417                 invalidationMessage()
01418             ));
01419         }
01420 
01421 
01422         return asyncCall(QLatin1String("GetSelfHandle"));
01423     }
01424 
01473     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message)
01474     {
01475         if (!invalidationReason().isEmpty()) {
01476             return QDBusPendingReply<>(QDBusMessage::createError(
01477                 invalidationReason(),
01478                 invalidationMessage()
01479             ));
01480         }
01481 
01482 
01483         QList<QVariant> argumentList;
01484         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01485         return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
01486     }
01487 
01507     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason)
01508     {
01509         if (!invalidationReason().isEmpty()) {
01510             return QDBusPendingReply<>(QDBusMessage::createError(
01511                 invalidationReason(),
01512                 invalidationMessage()
01513             ));
01514         }
01515 
01516 
01517         QList<QVariant> argumentList;
01518         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
01519         return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
01520     }
01521 
01522 Q_SIGNALS:
01541     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
01542 
01552     void SelfHandleChanged(uint selfHandle);
01553 
01568     void GroupFlagsChanged(uint added, uint removed);
01569 
01617     void MembersChanged(const QString& message, const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, uint actor, uint reason);
01618 
01719     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
01720 
01721 protected:
01722     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01723 };
01724 
01732 class ChannelInterfaceHoldInterface : public Tp::AbstractInterface
01733 {
01734     Q_OBJECT
01735 
01736 public:
01743     static inline const char *staticInterfaceName()
01744     {
01745         return "org.freedesktop.Telepathy.Channel.Interface.Hold";
01746     }
01747 
01755     ChannelInterfaceHoldInterface(
01756         const QString& busName,
01757         const QString& objectPath,
01758         QObject* parent = 0
01759     );
01760 
01769     ChannelInterfaceHoldInterface(
01770         const QDBusConnection& connection,
01771         const QString& busName,
01772         const QString& objectPath,
01773         QObject* parent = 0
01774     );
01775 
01782     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
01783 
01791     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
01792 
01800     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01801 
01802 public Q_SLOTS:
01816     inline QDBusPendingReply<uint, uint> GetHoldState()
01817     {
01818         if (!invalidationReason().isEmpty()) {
01819             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
01820                 invalidationReason(),
01821                 invalidationMessage()
01822             ));
01823         }
01824 
01825 
01826         return asyncCall(QLatin1String("GetHoldState"));
01827     }
01828 
01885     inline QDBusPendingReply<> RequestHold(bool hold)
01886     {
01887         if (!invalidationReason().isEmpty()) {
01888             return QDBusPendingReply<>(QDBusMessage::createError(
01889                 invalidationReason(),
01890                 invalidationMessage()
01891             ));
01892         }
01893 
01894 
01895         QList<QVariant> argumentList;
01896         argumentList << QVariant::fromValue(hold);
01897         return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
01898     }
01899 
01900 Q_SIGNALS:
01917     void HoldStateChanged(uint holdState, uint reason);
01918 
01919 protected:
01920     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01921 };
01922 
01930 class ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
01931 {
01932     Q_OBJECT
01933 
01934 public:
01941     static inline const char *staticInterfaceName()
01942     {
01943         return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
01944     }
01945 
01953     ChannelInterfaceMediaSignallingInterface(
01954         const QString& busName,
01955         const QString& objectPath,
01956         QObject* parent = 0
01957     );
01958 
01967     ChannelInterfaceMediaSignallingInterface(
01968         const QDBusConnection& connection,
01969         const QString& busName,
01970         const QString& objectPath,
01971         QObject* parent = 0
01972     );
01973 
01980     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
01981 
01989     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
01990 
01998     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01999 
02000 public Q_SLOTS:
02007     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
02008     {
02009         if (!invalidationReason().isEmpty()) {
02010             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02011                 invalidationReason(),
02012                 invalidationMessage()
02013             ));
02014         }
02015 
02016 
02017         return asyncCall(QLatin1String("GetSessionHandlers"));
02018     }
02019 
02020 Q_SIGNALS:
02036     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02037 
02038 protected:
02039     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02040 };
02041 
02049 class ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
02050 {
02051     Q_OBJECT
02052 
02053 public:
02060     static inline const char *staticInterfaceName()
02061     {
02062         return "org.freedesktop.Telepathy.Channel.Interface.Messages";
02063     }
02064 
02072     ChannelInterfaceMessagesInterface(
02073         const QString& busName,
02074         const QString& objectPath,
02075         QObject* parent = 0
02076     );
02077 
02086     ChannelInterfaceMessagesInterface(
02087         const QDBusConnection& connection,
02088         const QString& busName,
02089         const QString& objectPath,
02090         QObject* parent = 0
02091     );
02092 
02099     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
02100 
02108     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
02109 
02117     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02118 
02164     Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
02165 
02166     
02174     inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
02175     {
02176         return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
02177     }
02178 
02184     Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
02185 
02186     
02194     inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
02195     {
02196         return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
02197     }
02198 
02208     Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)
02209 
02210     
02218     inline Tp::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
02219     {
02220         return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
02221     }
02222 
02228     Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
02229 
02230     
02238     inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
02239     {
02240         return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
02241     }
02242 
02243 public Q_SLOTS:
02283     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
02284     {
02285         if (!invalidationReason().isEmpty()) {
02286             return QDBusPendingReply<QString>(QDBusMessage::createError(
02287                 invalidationReason(),
02288                 invalidationMessage()
02289             ));
02290         }
02291 
02292 
02293         QList<QVariant> argumentList;
02294         argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
02295         return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
02296     }
02297 
02331     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
02332     {
02333         if (!invalidationReason().isEmpty()) {
02334             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
02335                 invalidationReason(),
02336                 invalidationMessage()
02337             ));
02338         }
02339 
02340 
02341         QList<QVariant> argumentList;
02342         argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
02343         return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
02344     }
02345 
02346 Q_SIGNALS:
02392     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
02393 
02407     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
02408 
02423     void MessageReceived(const Tp::MessagePartList& message);
02424 
02425 protected:
02426     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02427 };
02428 
02436 class ChannelInterfacePasswordInterface : public Tp::AbstractInterface
02437 {
02438     Q_OBJECT
02439 
02440 public:
02447     static inline const char *staticInterfaceName()
02448     {
02449         return "org.freedesktop.Telepathy.Channel.Interface.Password";
02450     }
02451 
02459     ChannelInterfacePasswordInterface(
02460         const QString& busName,
02461         const QString& objectPath,
02462         QObject* parent = 0
02463     );
02464 
02473     ChannelInterfacePasswordInterface(
02474         const QDBusConnection& connection,
02475         const QString& busName,
02476         const QString& objectPath,
02477         QObject* parent = 0
02478     );
02479 
02486     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
02487 
02495     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
02496 
02504     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02505 
02506 public Q_SLOTS:
02519     inline QDBusPendingReply<uint> GetPasswordFlags()
02520     {
02521         if (!invalidationReason().isEmpty()) {
02522             return QDBusPendingReply<uint>(QDBusMessage::createError(
02523                 invalidationReason(),
02524                 invalidationMessage()
02525             ));
02526         }
02527 
02528 
02529         return asyncCall(QLatin1String("GetPasswordFlags"));
02530     }
02531 
02543     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
02544     {
02545         if (!invalidationReason().isEmpty()) {
02546             return QDBusPendingReply<bool>(QDBusMessage::createError(
02547                 invalidationReason(),
02548                 invalidationMessage()
02549             ));
02550         }
02551 
02552 
02553         QList<QVariant> argumentList;
02554         argumentList << QVariant::fromValue(password);
02555         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
02556     }
02557 
02558 Q_SIGNALS:
02573     void PasswordFlagsChanged(uint added, uint removed);
02574 
02575 protected:
02576     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02577 };
02578 
02586 class ChannelTypeContactListInterface : public Tp::AbstractInterface
02587 {
02588     Q_OBJECT
02589 
02590 public:
02597     static inline const char *staticInterfaceName()
02598     {
02599         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
02600     }
02601 
02609     ChannelTypeContactListInterface(
02610         const QString& busName,
02611         const QString& objectPath,
02612         QObject* parent = 0
02613     );
02614 
02623     ChannelTypeContactListInterface(
02624         const QDBusConnection& connection,
02625         const QString& busName,
02626         const QString& objectPath,
02627         QObject* parent = 0
02628     );
02629 
02636     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
02637 
02645     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
02646 
02654     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02655 
02656 protected:
02657     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02658 };
02659 
02667 class ChannelTypeFileTransferInterface : public Tp::AbstractInterface
02668 {
02669     Q_OBJECT
02670 
02671 public:
02678     static inline const char *staticInterfaceName()
02679     {
02680         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
02681     }
02682 
02690     ChannelTypeFileTransferInterface(
02691         const QString& busName,
02692         const QString& objectPath,
02693         QObject* parent = 0
02694     );
02695 
02704     ChannelTypeFileTransferInterface(
02705         const QDBusConnection& connection,
02706         const QString& busName,
02707         const QString& objectPath,
02708         QObject* parent = 0
02709     );
02710 
02717     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
02718 
02726     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
02727 
02735     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02736 
02743     Q_PROPERTY(uint State READ State)
02744 
02745     
02753     inline uint State() const TELEPATHY_GNUC_DEPRECATED
02754     {
02755         return qvariant_cast<uint>(internalPropGet("State"));
02756     }
02757 
02769     Q_PROPERTY(QString ContentType READ ContentType)
02770 
02771     
02779     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
02780     {
02781         return qvariant_cast<QString>(internalPropGet("ContentType"));
02782     }
02783 
02799     Q_PROPERTY(QString Filename READ Filename)
02800 
02801     
02809     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
02810     {
02811         return qvariant_cast<QString>(internalPropGet("Filename"));
02812     }
02813 
02831     Q_PROPERTY(qulonglong Size READ Size)
02832 
02833     
02841     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
02842     {
02843         return qvariant_cast<qulonglong>(internalPropGet("Size"));
02844     }
02845 
02866     Q_PROPERTY(uint ContentHashType READ ContentHashType)
02867 
02868     
02876     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
02877     {
02878         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
02879     }
02880 
02895     Q_PROPERTY(QString ContentHash READ ContentHash)
02896 
02897     
02905     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
02906     {
02907         return qvariant_cast<QString>(internalPropGet("ContentHash"));
02908     }
02909 
02921     Q_PROPERTY(QString Description READ Description)
02922 
02923     
02931     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
02932     {
02933         return qvariant_cast<QString>(internalPropGet("Description"));
02934     }
02935 
02946     Q_PROPERTY(qlonglong Date READ Date)
02947 
02948     
02956     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
02957     {
02958         return qvariant_cast<qlonglong>(internalPropGet("Date"));
02959     }
02960 
02983     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
02984 
02985     
02993     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
02994     {
02995         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
02996     }
02997 
03005     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
03006 
03007     
03015     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
03016     {
03017         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
03018     }
03019 
03036     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
03037 
03038     
03046     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
03047     {
03048         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
03049     }
03050 
03051 public Q_SLOTS:
03091     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
03092     {
03093         if (!invalidationReason().isEmpty()) {
03094             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03095                 invalidationReason(),
03096                 invalidationMessage()
03097             ));
03098         }
03099 
03100 
03101         QList<QVariant> argumentList;
03102         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
03103         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
03104     }
03105 
03134     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
03135     {
03136         if (!invalidationReason().isEmpty()) {
03137             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03138                 invalidationReason(),
03139                 invalidationMessage()
03140             ));
03141         }
03142 
03143 
03144         QList<QVariant> argumentList;
03145         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
03146         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
03147     }
03148 
03149 Q_SIGNALS:
03167     void FileTransferStateChanged(uint state, uint reason);
03168 
03181     void TransferredBytesChanged(qulonglong count);
03182 
03194     void InitialOffsetDefined(qulonglong initialOffset);
03195 
03196 protected:
03197     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03198 };
03199 
03207 class ChannelTypeRoomListInterface : public Tp::AbstractInterface
03208 {
03209     Q_OBJECT
03210 
03211 public:
03218     static inline const char *staticInterfaceName()
03219     {
03220         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
03221     }
03222 
03230     ChannelTypeRoomListInterface(
03231         const QString& busName,
03232         const QString& objectPath,
03233         QObject* parent = 0
03234     );
03235 
03244     ChannelTypeRoomListInterface(
03245         const QDBusConnection& connection,
03246         const QString& busName,
03247         const QString& objectPath,
03248         QObject* parent = 0
03249     );
03250 
03257     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
03258 
03266     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
03267 
03275     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03276 
03286     Q_PROPERTY(QString Server READ Server)
03287 
03288     
03296     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
03297     {
03298         return qvariant_cast<QString>(internalPropGet("Server"));
03299     }
03300 
03301 public Q_SLOTS:
03312     inline QDBusPendingReply<bool> GetListingRooms()
03313     {
03314         if (!invalidationReason().isEmpty()) {
03315             return QDBusPendingReply<bool>(QDBusMessage::createError(
03316                 invalidationReason(),
03317                 invalidationMessage()
03318             ));
03319         }
03320 
03321 
03322         return asyncCall(QLatin1String("GetListingRooms"));
03323     }
03324 
03333     inline QDBusPendingReply<> ListRooms()
03334     {
03335         if (!invalidationReason().isEmpty()) {
03336             return QDBusPendingReply<>(QDBusMessage::createError(
03337                 invalidationReason(),
03338                 invalidationMessage()
03339             ));
03340         }
03341 
03342 
03343         return asyncCall(QLatin1String("ListRooms"));
03344     }
03345 
03353     inline QDBusPendingReply<> StopListing()
03354     {
03355         if (!invalidationReason().isEmpty()) {
03356             return QDBusPendingReply<>(QDBusMessage::createError(
03357                 invalidationReason(),
03358                 invalidationMessage()
03359             ));
03360         }
03361 
03362 
03363         return asyncCall(QLatin1String("StopListing"));
03364     }
03365 
03366 Q_SIGNALS:
03411     void GotRooms(const Tp::RoomInfoList& rooms);
03412 
03423     void ListingRooms(bool listing);
03424 
03425 protected:
03426     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03427 };
03428 
03436 class ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
03437 {
03438     Q_OBJECT
03439 
03440 public:
03447     static inline const char *staticInterfaceName()
03448     {
03449         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
03450     }
03451 
03459     ChannelTypeStreamedMediaInterface(
03460         const QString& busName,
03461         const QString& objectPath,
03462         QObject* parent = 0
03463     );
03464 
03473     ChannelTypeStreamedMediaInterface(
03474         const QDBusConnection& connection,
03475         const QString& busName,
03476         const QString& objectPath,
03477         QObject* parent = 0
03478     );
03479 
03486     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
03487 
03495     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
03496 
03504     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03505 
03506 public Q_SLOTS:
03527     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
03528     {
03529         if (!invalidationReason().isEmpty()) {
03530             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
03531                 invalidationReason(),
03532                 invalidationMessage()
03533             ));
03534         }
03535 
03536 
03537         return asyncCall(QLatin1String("ListStreams"));
03538     }
03539 
03559     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
03560     {
03561         if (!invalidationReason().isEmpty()) {
03562             return QDBusPendingReply<>(QDBusMessage::createError(
03563                 invalidationReason(),
03564                 invalidationMessage()
03565             ));
03566         }
03567 
03568 
03569         QList<QVariant> argumentList;
03570         argumentList << QVariant::fromValue(streams);
03571         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
03572     }
03573 
03603     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
03604     {
03605         if (!invalidationReason().isEmpty()) {
03606             return QDBusPendingReply<>(QDBusMessage::createError(
03607                 invalidationReason(),
03608                 invalidationMessage()
03609             ));
03610         }
03611 
03612 
03613         QList<QVariant> argumentList;
03614         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
03615         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
03616     }
03617 
03661     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
03662     {
03663         if (!invalidationReason().isEmpty()) {
03664             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
03665                 invalidationReason(),
03666                 invalidationMessage()
03667             ));
03668         }
03669 
03670 
03671         QList<QVariant> argumentList;
03672         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
03673         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
03674     }
03675 
03676 Q_SIGNALS:
03741     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
03742 
03772     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
03773 
03791     void StreamError(uint streamID, uint errorCode, const QString& message);
03792 
03802     void StreamRemoved(uint streamID);
03803 
03817     void StreamStateChanged(uint streamID, uint streamState);
03818 
03819 protected:
03820     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03821 };
03822 
03830 class ChannelTypeTextInterface : public Tp::AbstractInterface
03831 {
03832     Q_OBJECT
03833 
03834 public:
03841     static inline const char *staticInterfaceName()
03842     {
03843         return "org.freedesktop.Telepathy.Channel.Type.Text";
03844     }
03845 
03853     ChannelTypeTextInterface(
03854         const QString& busName,
03855         const QString& objectPath,
03856         QObject* parent = 0
03857     );
03858 
03867     ChannelTypeTextInterface(
03868         const QDBusConnection& connection,
03869         const QString& busName,
03870         const QString& objectPath,
03871         QObject* parent = 0
03872     );
03873 
03880     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
03881 
03889     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
03890 
03898     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03899 
03900 public Q_SLOTS:
03911     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
03912     {
03913         if (!invalidationReason().isEmpty()) {
03914             return QDBusPendingReply<>(QDBusMessage::createError(
03915                 invalidationReason(),
03916                 invalidationMessage()
03917             ));
03918         }
03919 
03920 
03921         QList<QVariant> argumentList;
03922         argumentList << QVariant::fromValue(IDs);
03923         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
03924     }
03925 
03936     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
03937     {
03938         if (!invalidationReason().isEmpty()) {
03939             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
03940                 invalidationReason(),
03941                 invalidationMessage()
03942             ));
03943         }
03944 
03945 
03946         return asyncCall(QLatin1String("GetMessageTypes"));
03947     }
03948 
03972     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
03973     {
03974         if (!invalidationReason().isEmpty()) {
03975             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
03976                 invalidationReason(),
03977                 invalidationMessage()
03978             ));
03979         }
03980 
03981 
03982         QList<QVariant> argumentList;
03983         argumentList << QVariant::fromValue(clear);
03984         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
03985     }
03986 
04012     inline QDBusPendingReply<> Send(uint type, const QString& text)
04013     {
04014         if (!invalidationReason().isEmpty()) {
04015             return QDBusPendingReply<>(QDBusMessage::createError(
04016                 invalidationReason(),
04017                 invalidationMessage()
04018             ));
04019         }
04020 
04021 
04022         QList<QVariant> argumentList;
04023         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
04024         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
04025     }
04026 
04027 Q_SIGNALS:
04035     void LostMessage();
04036 
04070     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
04071 
04098     void SendError(uint error, uint timestamp, uint type, const QString& text);
04099 
04121     void Sent(uint timestamp, uint type, const QString& text);
04122 
04123 protected:
04124     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04125 };
04126 
04134 class ChannelTypeTubesInterface : public Tp::AbstractInterface
04135 {
04136     Q_OBJECT
04137 
04138 public:
04145     static inline const char *staticInterfaceName()
04146     {
04147         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
04148     }
04149 
04157     ChannelTypeTubesInterface(
04158         const QString& busName,
04159         const QString& objectPath,
04160         QObject* parent = 0
04161     );
04162 
04171     ChannelTypeTubesInterface(
04172         const QDBusConnection& connection,
04173         const QString& busName,
04174         const QString& objectPath,
04175         QObject* parent = 0
04176     );
04177 
04184     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
04185 
04193     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
04194 
04202     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04203 
04204 public Q_SLOTS:
04234     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
04235     {
04236         if (!invalidationReason().isEmpty()) {
04237             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
04238                 invalidationReason(),
04239                 invalidationMessage()
04240             ));
04241         }
04242 
04243 
04244         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
04245     }
04246 
04255     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
04256     {
04257         if (!invalidationReason().isEmpty()) {
04258             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
04259                 invalidationReason(),
04260                 invalidationMessage()
04261             ));
04262         }
04263 
04264 
04265         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
04266     }
04267 
04278     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
04279     {
04280         if (!invalidationReason().isEmpty()) {
04281             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
04282                 invalidationReason(),
04283                 invalidationMessage()
04284             ));
04285         }
04286 
04287 
04288         return asyncCall(QLatin1String("ListTubes"));
04289     }
04290 
04313     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
04314     {
04315         if (!invalidationReason().isEmpty()) {
04316             return QDBusPendingReply<uint>(QDBusMessage::createError(
04317                 invalidationReason(),
04318                 invalidationMessage()
04319             ));
04320         }
04321 
04322 
04323         QList<QVariant> argumentList;
04324         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
04325         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
04326     }
04327 
04378     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
04379     {
04380         if (!invalidationReason().isEmpty()) {
04381             return QDBusPendingReply<uint>(QDBusMessage::createError(
04382                 invalidationReason(),
04383                 invalidationMessage()
04384             ));
04385         }
04386 
04387 
04388         QList<QVariant> argumentList;
04389         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
04390         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
04391     }
04392 
04410     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
04411     {
04412         if (!invalidationReason().isEmpty()) {
04413             return QDBusPendingReply<QString>(QDBusMessage::createError(
04414                 invalidationReason(),
04415                 invalidationMessage()
04416             ));
04417         }
04418 
04419 
04420         QList<QVariant> argumentList;
04421         argumentList << QVariant::fromValue(ID);
04422         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
04423     }
04424 
04457     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
04458     {
04459         if (!invalidationReason().isEmpty()) {
04460             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04461                 invalidationReason(),
04462                 invalidationMessage()
04463             ));
04464         }
04465 
04466 
04467         QList<QVariant> argumentList;
04468         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
04469         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
04470     }
04471 
04481     inline QDBusPendingReply<> CloseTube(uint ID)
04482     {
04483         if (!invalidationReason().isEmpty()) {
04484             return QDBusPendingReply<>(QDBusMessage::createError(
04485                 invalidationReason(),
04486                 invalidationMessage()
04487             ));
04488         }
04489 
04490 
04491         QList<QVariant> argumentList;
04492         argumentList << QVariant::fromValue(ID);
04493         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
04494     }
04495 
04510     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
04511     {
04512         if (!invalidationReason().isEmpty()) {
04513             return QDBusPendingReply<QString>(QDBusMessage::createError(
04514                 invalidationReason(),
04515                 invalidationMessage()
04516             ));
04517         }
04518 
04519 
04520         QList<QVariant> argumentList;
04521         argumentList << QVariant::fromValue(ID);
04522         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
04523     }
04524 
04540     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
04541     {
04542         if (!invalidationReason().isEmpty()) {
04543             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
04544                 invalidationReason(),
04545                 invalidationMessage()
04546             ));
04547         }
04548 
04549 
04550         QList<QVariant> argumentList;
04551         argumentList << QVariant::fromValue(ID);
04552         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
04553     }
04554 
04575     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
04576     {
04577         if (!invalidationReason().isEmpty()) {
04578             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
04579                 invalidationReason(),
04580                 invalidationMessage()
04581             ));
04582         }
04583 
04584 
04585         QList<QVariant> argumentList;
04586         argumentList << QVariant::fromValue(ID);
04587         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
04588     }
04589 
04590 Q_SIGNALS:
04620     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
04621 
04635     void TubeStateChanged(uint ID, uint state);
04636 
04647     void TubeClosed(uint ID);
04648 
04667     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
04668 
04683     void StreamTubeNewConnection(uint ID, uint handle);
04684 
04685 protected:
04686     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04687 };
04688 }
04689 }


Copyright © 2009 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.1.10