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 #include <TelepathyQt4/Global>
00025 
00026 // basically the same as GLib's G_GNUC_DEPRECATED
00027 #ifndef TELEPATHY_GNUC_DEPRECATED
00028 #   if defined(Q_CC_GNUC) && __GNUC__ >= 4
00029 #       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
00030 #   else
00031 #       define TELEPATHY_GNUC_DEPRECATED
00032 #   endif
00033 #endif
00034 namespace Tp
00035 {
00036 namespace Client
00037 {
00038 
00046 class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
00047 {
00048     Q_OBJECT
00049 
00050 public:
00057     static inline const char *staticInterfaceName()
00058     {
00059         return "org.freedesktop.Telepathy.Channel";
00060     }
00061 
00069     ChannelInterface(
00070         const QString& busName,
00071         const QString& objectPath,
00072         QObject* parent = 0
00073     );
00074 
00083     ChannelInterface(
00084         const QDBusConnection& connection,
00085         const QString& busName,
00086         const QString& objectPath,
00087         QObject* parent = 0
00088     );
00089 
00096     ChannelInterface(Tp::DBusProxy *proxy);
00097 
00122     Q_PROPERTY(QString ChannelType READ ChannelType)
00123 
00124     
00132     inline QString ChannelType() const TELEPATHY_GNUC_DEPRECATED
00133     {
00134         return qvariant_cast<QString>(internalPropGet("ChannelType"));
00135     }
00136 
00164     Q_PROPERTY(QStringList Interfaces READ Interfaces)
00165 
00166     
00174     inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
00175     {
00176         return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
00177     }
00178 
00215     Q_PROPERTY(uint TargetHandle READ TargetHandle)
00216 
00217     
00225     inline uint TargetHandle() const TELEPATHY_GNUC_DEPRECATED
00226     {
00227         return qvariant_cast<uint>(internalPropGet("TargetHandle"));
00228     }
00229 
00274     Q_PROPERTY(QString TargetID READ TargetID)
00275 
00276     
00284     inline QString TargetID() const TELEPATHY_GNUC_DEPRECATED
00285     {
00286         return qvariant_cast<QString>(internalPropGet("TargetID"));
00287     }
00288 
00302     Q_PROPERTY(uint TargetHandleType READ TargetHandleType)
00303 
00304     
00312     inline uint TargetHandleType() const TELEPATHY_GNUC_DEPRECATED
00313     {
00314         return qvariant_cast<uint>(internalPropGet("TargetHandleType"));
00315     }
00316 
00379     Q_PROPERTY(bool Requested READ Requested)
00380 
00381     
00389     inline bool Requested() const TELEPATHY_GNUC_DEPRECATED
00390     {
00391         return qvariant_cast<bool>(internalPropGet("Requested"));
00392     }
00393 
00449     Q_PROPERTY(uint InitiatorHandle READ InitiatorHandle)
00450 
00451     
00459     inline uint InitiatorHandle() const TELEPATHY_GNUC_DEPRECATED
00460     {
00461         return qvariant_cast<uint>(internalPropGet("InitiatorHandle"));
00462     }
00463 
00492     Q_PROPERTY(QString InitiatorID READ InitiatorID)
00493 
00494     
00502     inline QString InitiatorID() const TELEPATHY_GNUC_DEPRECATED
00503     {
00504         return qvariant_cast<QString>(internalPropGet("InitiatorID"));
00505     }
00506 
00507 public Q_SLOTS:
00517     inline QDBusPendingReply<> Close()
00518     {
00519         if (!invalidationReason().isEmpty()) {
00520             return QDBusPendingReply<>(QDBusMessage::createError(
00521                 invalidationReason(),
00522                 invalidationMessage()
00523             ));
00524         }
00525 
00526 
00527         return asyncCall(QLatin1String("Close"));
00528     }
00529 
00542     inline QDBusPendingReply<QString> GetChannelType()
00543     {
00544         if (!invalidationReason().isEmpty()) {
00545             return QDBusPendingReply<QString>(QDBusMessage::createError(
00546                 invalidationReason(),
00547                 invalidationMessage()
00548             ));
00549         }
00550 
00551 
00552         return asyncCall(QLatin1String("GetChannelType"));
00553     }
00554 
00573     inline QDBusPendingReply<uint, uint> GetHandle()
00574     {
00575         if (!invalidationReason().isEmpty()) {
00576             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00577                 invalidationReason(),
00578                 invalidationMessage()
00579             ));
00580         }
00581 
00582 
00583         return asyncCall(QLatin1String("GetHandle"));
00584     }
00585 
00598     inline QDBusPendingReply<QStringList> GetInterfaces()
00599     {
00600         if (!invalidationReason().isEmpty()) {
00601             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00602                 invalidationReason(),
00603                 invalidationMessage()
00604             ));
00605         }
00606 
00607 
00608         return asyncCall(QLatin1String("GetInterfaces"));
00609     }
00610 
00611 Q_SIGNALS:
00619     void Closed();
00620 
00621 protected:
00622     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00623 };
00624 
00632 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00633 {
00634     Q_OBJECT
00635 
00636 public:
00643     static inline const char *staticInterfaceName()
00644     {
00645         return "org.freedesktop.Telepathy.Channel.Interface.CallState";
00646     }
00647 
00655     ChannelInterfaceCallStateInterface(
00656         const QString& busName,
00657         const QString& objectPath,
00658         QObject* parent = 0
00659     );
00660 
00669     ChannelInterfaceCallStateInterface(
00670         const QDBusConnection& connection,
00671         const QString& busName,
00672         const QString& objectPath,
00673         QObject* parent = 0
00674     );
00675 
00682     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00683 
00691     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00692 
00700     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00701 
00702 public Q_SLOTS:
00713     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
00714     {
00715         if (!invalidationReason().isEmpty()) {
00716             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00717                 invalidationReason(),
00718                 invalidationMessage()
00719             ));
00720         }
00721 
00722 
00723         return asyncCall(QLatin1String("GetCallStates"));
00724     }
00725 
00726 Q_SIGNALS:
00740     void CallStateChanged(uint contact, uint state);
00741 
00742 protected:
00743     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00744 };
00745 
00753 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00754 {
00755     Q_OBJECT
00756 
00757 public:
00764     static inline const char *staticInterfaceName()
00765     {
00766         return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
00767     }
00768 
00776     ChannelInterfaceChatStateInterface(
00777         const QString& busName,
00778         const QString& objectPath,
00779         QObject* parent = 0
00780     );
00781 
00790     ChannelInterfaceChatStateInterface(
00791         const QDBusConnection& connection,
00792         const QString& busName,
00793         const QString& objectPath,
00794         QObject* parent = 0
00795     );
00796 
00803     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00804 
00812     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00813 
00821     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00822 
00823 public Q_SLOTS:
00834     inline QDBusPendingReply<> SetChatState(uint state)
00835     {
00836         if (!invalidationReason().isEmpty()) {
00837             return QDBusPendingReply<>(QDBusMessage::createError(
00838                 invalidationReason(),
00839                 invalidationMessage()
00840             ));
00841         }
00842 
00843 
00844         QList<QVariant> argumentList;
00845         argumentList << QVariant::fromValue(state);
00846         return asyncCallWithArgumentList(QLatin1String("SetChatState"), argumentList);
00847     }
00848 
00849 Q_SIGNALS:
00864     void ChatStateChanged(uint contact, uint state);
00865 
00866 protected:
00867     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00868 };
00869 
00877 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
00878 {
00879     Q_OBJECT
00880 
00881 public:
00888     static inline const char *staticInterfaceName()
00889     {
00890         return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
00891     }
00892 
00900     ChannelInterfaceDTMFInterface(
00901         const QString& busName,
00902         const QString& objectPath,
00903         QObject* parent = 0
00904     );
00905 
00914     ChannelInterfaceDTMFInterface(
00915         const QDBusConnection& connection,
00916         const QString& busName,
00917         const QString& objectPath,
00918         QObject* parent = 0
00919     );
00920 
00927     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
00928 
00936     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
00937 
00945     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00946 
00947 public Q_SLOTS:
00965     inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
00966     {
00967         if (!invalidationReason().isEmpty()) {
00968             return QDBusPendingReply<>(QDBusMessage::createError(
00969                 invalidationReason(),
00970                 invalidationMessage()
00971             ));
00972         }
00973 
00974 
00975         QList<QVariant> argumentList;
00976         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
00977         return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
00978     }
00979 
00990     inline QDBusPendingReply<> StopTone(uint streamID)
00991     {
00992         if (!invalidationReason().isEmpty()) {
00993             return QDBusPendingReply<>(QDBusMessage::createError(
00994                 invalidationReason(),
00995                 invalidationMessage()
00996             ));
00997         }
00998 
00999 
01000         QList<QVariant> argumentList;
01001         argumentList << QVariant::fromValue(streamID);
01002         return asyncCallWithArgumentList(QLatin1String("StopTone"), argumentList);
01003     }
01004 
01005 protected:
01006     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01007 };
01008 
01016 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
01017 {
01018     Q_OBJECT
01019 
01020 public:
01027     static inline const char *staticInterfaceName()
01028     {
01029         return "org.freedesktop.Telepathy.Channel.Interface.Group";
01030     }
01031 
01039     ChannelInterfaceGroupInterface(
01040         const QString& busName,
01041         const QString& objectPath,
01042         QObject* parent = 0
01043     );
01044 
01053     ChannelInterfaceGroupInterface(
01054         const QDBusConnection& connection,
01055         const QString& busName,
01056         const QString& objectPath,
01057         QObject* parent = 0
01058     );
01059 
01066     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01067 
01075     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01076 
01084     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01085 
01094     Q_PROPERTY(uint GroupFlags READ GroupFlags)
01095 
01096     
01104     inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
01105     {
01106         return qvariant_cast<uint>(internalPropGet("GroupFlags"));
01107     }
01108 
01120     Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)
01121 
01122     
01130     inline Tp::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
01131     {
01132         return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
01133     }
01134 
01141     Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
01142 
01143     
01151     inline Tp::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
01152     {
01153         return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
01154     }
01155 
01161     Q_PROPERTY(Tp::UIntList Members READ Members)
01162 
01163     
01171     inline Tp::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
01172     {
01173         return qvariant_cast<Tp::UIntList>(internalPropGet("Members"));
01174     }
01175 
01182     Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)
01183 
01184     
01192     inline Tp::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
01193     {
01194         return qvariant_cast<Tp::UIntList>(internalPropGet("RemotePendingMembers"));
01195     }
01196 
01207     Q_PROPERTY(uint SelfHandle READ SelfHandle)
01208 
01209     
01217     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
01218     {
01219         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
01220     }
01221 
01222 public Q_SLOTS:
01246     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message)
01247     {
01248         if (!invalidationReason().isEmpty()) {
01249             return QDBusPendingReply<>(QDBusMessage::createError(
01250                 invalidationReason(),
01251                 invalidationMessage()
01252             ));
01253         }
01254 
01255 
01256         QList<QVariant> argumentList;
01257         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01258         return asyncCallWithArgumentList(QLatin1String("AddMembers"), argumentList);
01259     }
01260 
01278     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers()
01279     {
01280         if (!invalidationReason().isEmpty()) {
01281             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
01282                 invalidationReason(),
01283                 invalidationMessage()
01284             ));
01285         }
01286 
01287 
01288         return asyncCall(QLatin1String("GetAllMembers"));
01289     }
01290 
01300     inline QDBusPendingReply<uint> GetGroupFlags()
01301     {
01302         if (!invalidationReason().isEmpty()) {
01303             return QDBusPendingReply<uint>(QDBusMessage::createError(
01304                 invalidationReason(),
01305                 invalidationMessage()
01306             ));
01307         }
01308 
01309 
01310         return asyncCall(QLatin1String("GetGroupFlags"));
01311     }
01312 
01333     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles)
01334     {
01335         if (!invalidationReason().isEmpty()) {
01336             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01337                 invalidationReason(),
01338                 invalidationMessage()
01339             ));
01340         }
01341 
01342 
01343         QList<QVariant> argumentList;
01344         argumentList << QVariant::fromValue(handles);
01345         return asyncCallWithArgumentList(QLatin1String("GetHandleOwners"), argumentList);
01346     }
01347 
01354     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
01355     {
01356         if (!invalidationReason().isEmpty()) {
01357             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01358                 invalidationReason(),
01359                 invalidationMessage()
01360             ));
01361         }
01362 
01363 
01364         return asyncCall(QLatin1String("GetLocalPendingMembers"));
01365     }
01366 
01380     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
01381     {
01382         if (!invalidationReason().isEmpty()) {
01383             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
01384                 invalidationReason(),
01385                 invalidationMessage()
01386             ));
01387         }
01388 
01389 
01390         return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
01391     }
01392 
01398     inline QDBusPendingReply<Tp::UIntList> GetMembers()
01399     {
01400         if (!invalidationReason().isEmpty()) {
01401             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01402                 invalidationReason(),
01403                 invalidationMessage()
01404             ));
01405         }
01406 
01407 
01408         return asyncCall(QLatin1String("GetMembers"));
01409     }
01410 
01417     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
01418     {
01419         if (!invalidationReason().isEmpty()) {
01420             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01421                 invalidationReason(),
01422                 invalidationMessage()
01423             ));
01424         }
01425 
01426 
01427         return asyncCall(QLatin1String("GetRemotePendingMembers"));
01428     }
01429 
01435     inline QDBusPendingReply<uint> GetSelfHandle()
01436     {
01437         if (!invalidationReason().isEmpty()) {
01438             return QDBusPendingReply<uint>(QDBusMessage::createError(
01439                 invalidationReason(),
01440                 invalidationMessage()
01441             ));
01442         }
01443 
01444 
01445         return asyncCall(QLatin1String("GetSelfHandle"));
01446     }
01447 
01496     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message)
01497     {
01498         if (!invalidationReason().isEmpty()) {
01499             return QDBusPendingReply<>(QDBusMessage::createError(
01500                 invalidationReason(),
01501                 invalidationMessage()
01502             ));
01503         }
01504 
01505 
01506         QList<QVariant> argumentList;
01507         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01508         return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
01509     }
01510 
01530     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason)
01531     {
01532         if (!invalidationReason().isEmpty()) {
01533             return QDBusPendingReply<>(QDBusMessage::createError(
01534                 invalidationReason(),
01535                 invalidationMessage()
01536             ));
01537         }
01538 
01539 
01540         QList<QVariant> argumentList;
01541         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
01542         return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
01543     }
01544 
01545 Q_SIGNALS:
01564     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
01565 
01575     void SelfHandleChanged(uint selfHandle);
01576 
01591     void GroupFlagsChanged(uint added, uint removed);
01592 
01640     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);
01641 
01742     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
01743 
01744 protected:
01745     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01746 };
01747 
01755 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
01756 {
01757     Q_OBJECT
01758 
01759 public:
01766     static inline const char *staticInterfaceName()
01767     {
01768         return "org.freedesktop.Telepathy.Channel.Interface.Hold";
01769     }
01770 
01778     ChannelInterfaceHoldInterface(
01779         const QString& busName,
01780         const QString& objectPath,
01781         QObject* parent = 0
01782     );
01783 
01792     ChannelInterfaceHoldInterface(
01793         const QDBusConnection& connection,
01794         const QString& busName,
01795         const QString& objectPath,
01796         QObject* parent = 0
01797     );
01798 
01805     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
01806 
01814     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
01815 
01823     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01824 
01825 public Q_SLOTS:
01839     inline QDBusPendingReply<uint, uint> GetHoldState()
01840     {
01841         if (!invalidationReason().isEmpty()) {
01842             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
01843                 invalidationReason(),
01844                 invalidationMessage()
01845             ));
01846         }
01847 
01848 
01849         return asyncCall(QLatin1String("GetHoldState"));
01850     }
01851 
01908     inline QDBusPendingReply<> RequestHold(bool hold)
01909     {
01910         if (!invalidationReason().isEmpty()) {
01911             return QDBusPendingReply<>(QDBusMessage::createError(
01912                 invalidationReason(),
01913                 invalidationMessage()
01914             ));
01915         }
01916 
01917 
01918         QList<QVariant> argumentList;
01919         argumentList << QVariant::fromValue(hold);
01920         return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
01921     }
01922 
01923 Q_SIGNALS:
01940     void HoldStateChanged(uint holdState, uint reason);
01941 
01942 protected:
01943     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01944 };
01945 
01953 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
01954 {
01955     Q_OBJECT
01956 
01957 public:
01964     static inline const char *staticInterfaceName()
01965     {
01966         return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
01967     }
01968 
01976     ChannelInterfaceMediaSignallingInterface(
01977         const QString& busName,
01978         const QString& objectPath,
01979         QObject* parent = 0
01980     );
01981 
01990     ChannelInterfaceMediaSignallingInterface(
01991         const QDBusConnection& connection,
01992         const QString& busName,
01993         const QString& objectPath,
01994         QObject* parent = 0
01995     );
01996 
02003     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
02004 
02012     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
02013 
02021     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02022 
02023 public Q_SLOTS:
02030     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
02031     {
02032         if (!invalidationReason().isEmpty()) {
02033             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02034                 invalidationReason(),
02035                 invalidationMessage()
02036             ));
02037         }
02038 
02039 
02040         return asyncCall(QLatin1String("GetSessionHandlers"));
02041     }
02042 
02043 Q_SIGNALS:
02059     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02060 
02061 protected:
02062     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02063 };
02064 
02072 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
02073 {
02074     Q_OBJECT
02075 
02076 public:
02083     static inline const char *staticInterfaceName()
02084     {
02085         return "org.freedesktop.Telepathy.Channel.Interface.Messages";
02086     }
02087 
02095     ChannelInterfaceMessagesInterface(
02096         const QString& busName,
02097         const QString& objectPath,
02098         QObject* parent = 0
02099     );
02100 
02109     ChannelInterfaceMessagesInterface(
02110         const QDBusConnection& connection,
02111         const QString& busName,
02112         const QString& objectPath,
02113         QObject* parent = 0
02114     );
02115 
02122     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
02123 
02131     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
02132 
02140     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02141 
02187     Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
02188 
02189     
02197     inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
02198     {
02199         return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
02200     }
02201 
02207     Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
02208 
02209     
02217     inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
02218     {
02219         return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
02220     }
02221 
02231     Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)
02232 
02233     
02241     inline Tp::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
02242     {
02243         return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
02244     }
02245 
02251     Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
02252 
02253     
02261     inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
02262     {
02263         return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
02264     }
02265 
02266 public Q_SLOTS:
02306     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
02307     {
02308         if (!invalidationReason().isEmpty()) {
02309             return QDBusPendingReply<QString>(QDBusMessage::createError(
02310                 invalidationReason(),
02311                 invalidationMessage()
02312             ));
02313         }
02314 
02315 
02316         QList<QVariant> argumentList;
02317         argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
02318         return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
02319     }
02320 
02354     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
02355     {
02356         if (!invalidationReason().isEmpty()) {
02357             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
02358                 invalidationReason(),
02359                 invalidationMessage()
02360             ));
02361         }
02362 
02363 
02364         QList<QVariant> argumentList;
02365         argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
02366         return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
02367     }
02368 
02369 Q_SIGNALS:
02416     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
02417 
02431     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
02432 
02447     void MessageReceived(const Tp::MessagePartList& message);
02448 
02449 protected:
02450     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02451 };
02452 
02460 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
02461 {
02462     Q_OBJECT
02463 
02464 public:
02471     static inline const char *staticInterfaceName()
02472     {
02473         return "org.freedesktop.Telepathy.Channel.Interface.Password";
02474     }
02475 
02483     ChannelInterfacePasswordInterface(
02484         const QString& busName,
02485         const QString& objectPath,
02486         QObject* parent = 0
02487     );
02488 
02497     ChannelInterfacePasswordInterface(
02498         const QDBusConnection& connection,
02499         const QString& busName,
02500         const QString& objectPath,
02501         QObject* parent = 0
02502     );
02503 
02510     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
02511 
02519     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
02520 
02528     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02529 
02530 public Q_SLOTS:
02543     inline QDBusPendingReply<uint> GetPasswordFlags()
02544     {
02545         if (!invalidationReason().isEmpty()) {
02546             return QDBusPendingReply<uint>(QDBusMessage::createError(
02547                 invalidationReason(),
02548                 invalidationMessage()
02549             ));
02550         }
02551 
02552 
02553         return asyncCall(QLatin1String("GetPasswordFlags"));
02554     }
02555 
02571     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
02572     {
02573         if (!invalidationReason().isEmpty()) {
02574             return QDBusPendingReply<bool>(QDBusMessage::createError(
02575                 invalidationReason(),
02576                 invalidationMessage()
02577             ));
02578         }
02579 
02580 
02581         QList<QVariant> argumentList;
02582         argumentList << QVariant::fromValue(password);
02583         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
02584     }
02585 
02586 Q_SIGNALS:
02601     void PasswordFlagsChanged(uint added, uint removed);
02602 
02603 protected:
02604     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02605 };
02606 
02614 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
02615 {
02616     Q_OBJECT
02617 
02618 public:
02625     static inline const char *staticInterfaceName()
02626     {
02627         return "org.freedesktop.Telepathy.Channel.Interface.Tube";
02628     }
02629 
02637     ChannelInterfaceTubeInterface(
02638         const QString& busName,
02639         const QString& objectPath,
02640         QObject* parent = 0
02641     );
02642 
02651     ChannelInterfaceTubeInterface(
02652         const QDBusConnection& connection,
02653         const QString& busName,
02654         const QString& objectPath,
02655         QObject* parent = 0
02656     );
02657 
02664     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
02665 
02673     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
02674 
02682     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02683 
02723     Q_PROPERTY(QVariantMap Parameters READ Parameters)
02724 
02725     
02733     inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
02734     {
02735         return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
02736     }
02737 
02747     Q_PROPERTY(uint State READ State)
02748 
02749     
02757     inline uint State() const TELEPATHY_GNUC_DEPRECATED
02758     {
02759         return qvariant_cast<uint>(internalPropGet("State"));
02760     }
02761 
02762 Q_SIGNALS:
02773     void TubeChannelStateChanged(uint state);
02774 
02775 protected:
02776     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02777 };
02778 
02786 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
02787 {
02788     Q_OBJECT
02789 
02790 public:
02797     static inline const char *staticInterfaceName()
02798     {
02799         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
02800     }
02801 
02809     ChannelTypeContactListInterface(
02810         const QString& busName,
02811         const QString& objectPath,
02812         QObject* parent = 0
02813     );
02814 
02823     ChannelTypeContactListInterface(
02824         const QDBusConnection& connection,
02825         const QString& busName,
02826         const QString& objectPath,
02827         QObject* parent = 0
02828     );
02829 
02836     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
02837 
02845     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
02846 
02854     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02855 
02856 protected:
02857     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02858 };
02859 
02867 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
02868 {
02869     Q_OBJECT
02870 
02871 public:
02878     static inline const char *staticInterfaceName()
02879     {
02880         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
02881     }
02882 
02890     ChannelTypeFileTransferInterface(
02891         const QString& busName,
02892         const QString& objectPath,
02893         QObject* parent = 0
02894     );
02895 
02904     ChannelTypeFileTransferInterface(
02905         const QDBusConnection& connection,
02906         const QString& busName,
02907         const QString& objectPath,
02908         QObject* parent = 0
02909     );
02910 
02917     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
02918 
02926     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
02927 
02935     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02936 
02943     Q_PROPERTY(uint State READ State)
02944 
02945     
02953     inline uint State() const TELEPATHY_GNUC_DEPRECATED
02954     {
02955         return qvariant_cast<uint>(internalPropGet("State"));
02956     }
02957 
02969     Q_PROPERTY(QString ContentType READ ContentType)
02970 
02971     
02979     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
02980     {
02981         return qvariant_cast<QString>(internalPropGet("ContentType"));
02982     }
02983 
02999     Q_PROPERTY(QString Filename READ Filename)
03000 
03001     
03009     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
03010     {
03011         return qvariant_cast<QString>(internalPropGet("Filename"));
03012     }
03013 
03031     Q_PROPERTY(qulonglong Size READ Size)
03032 
03033     
03041     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
03042     {
03043         return qvariant_cast<qulonglong>(internalPropGet("Size"));
03044     }
03045 
03066     Q_PROPERTY(uint ContentHashType READ ContentHashType)
03067 
03068     
03076     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
03077     {
03078         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
03079     }
03080 
03095     Q_PROPERTY(QString ContentHash READ ContentHash)
03096 
03097     
03105     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
03106     {
03107         return qvariant_cast<QString>(internalPropGet("ContentHash"));
03108     }
03109 
03121     Q_PROPERTY(QString Description READ Description)
03122 
03123     
03131     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
03132     {
03133         return qvariant_cast<QString>(internalPropGet("Description"));
03134     }
03135 
03146     Q_PROPERTY(qlonglong Date READ Date)
03147 
03148     
03156     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
03157     {
03158         return qvariant_cast<qlonglong>(internalPropGet("Date"));
03159     }
03160 
03183     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
03184 
03185     
03193     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
03194     {
03195         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
03196     }
03197 
03205     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
03206 
03207     
03215     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
03216     {
03217         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
03218     }
03219 
03236     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
03237 
03238     
03246     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
03247     {
03248         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
03249     }
03250 
03251 public Q_SLOTS:
03291     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
03292     {
03293         if (!invalidationReason().isEmpty()) {
03294             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03295                 invalidationReason(),
03296                 invalidationMessage()
03297             ));
03298         }
03299 
03300 
03301         QList<QVariant> argumentList;
03302         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
03303         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
03304     }
03305 
03334     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
03335     {
03336         if (!invalidationReason().isEmpty()) {
03337             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03338                 invalidationReason(),
03339                 invalidationMessage()
03340             ));
03341         }
03342 
03343 
03344         QList<QVariant> argumentList;
03345         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
03346         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
03347     }
03348 
03349 Q_SIGNALS:
03367     void FileTransferStateChanged(uint state, uint reason);
03368 
03381     void TransferredBytesChanged(qulonglong count);
03382 
03394     void InitialOffsetDefined(qulonglong initialOffset);
03395 
03396 protected:
03397     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03398 };
03399 
03407 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
03408 {
03409     Q_OBJECT
03410 
03411 public:
03418     static inline const char *staticInterfaceName()
03419     {
03420         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
03421     }
03422 
03430     ChannelTypeRoomListInterface(
03431         const QString& busName,
03432         const QString& objectPath,
03433         QObject* parent = 0
03434     );
03435 
03444     ChannelTypeRoomListInterface(
03445         const QDBusConnection& connection,
03446         const QString& busName,
03447         const QString& objectPath,
03448         QObject* parent = 0
03449     );
03450 
03457     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
03458 
03466     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
03467 
03475     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03476 
03486     Q_PROPERTY(QString Server READ Server)
03487 
03488     
03496     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
03497     {
03498         return qvariant_cast<QString>(internalPropGet("Server"));
03499     }
03500 
03501 public Q_SLOTS:
03512     inline QDBusPendingReply<bool> GetListingRooms()
03513     {
03514         if (!invalidationReason().isEmpty()) {
03515             return QDBusPendingReply<bool>(QDBusMessage::createError(
03516                 invalidationReason(),
03517                 invalidationMessage()
03518             ));
03519         }
03520 
03521 
03522         return asyncCall(QLatin1String("GetListingRooms"));
03523     }
03524 
03533     inline QDBusPendingReply<> ListRooms()
03534     {
03535         if (!invalidationReason().isEmpty()) {
03536             return QDBusPendingReply<>(QDBusMessage::createError(
03537                 invalidationReason(),
03538                 invalidationMessage()
03539             ));
03540         }
03541 
03542 
03543         return asyncCall(QLatin1String("ListRooms"));
03544     }
03545 
03553     inline QDBusPendingReply<> StopListing()
03554     {
03555         if (!invalidationReason().isEmpty()) {
03556             return QDBusPendingReply<>(QDBusMessage::createError(
03557                 invalidationReason(),
03558                 invalidationMessage()
03559             ));
03560         }
03561 
03562 
03563         return asyncCall(QLatin1String("StopListing"));
03564     }
03565 
03566 Q_SIGNALS:
03611     void GotRooms(const Tp::RoomInfoList& rooms);
03612 
03623     void ListingRooms(bool listing);
03624 
03625 protected:
03626     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03627 };
03628 
03636 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
03637 {
03638     Q_OBJECT
03639 
03640 public:
03647     static inline const char *staticInterfaceName()
03648     {
03649         return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
03650     }
03651 
03659     ChannelTypeStreamTubeInterface(
03660         const QString& busName,
03661         const QString& objectPath,
03662         QObject* parent = 0
03663     );
03664 
03673     ChannelTypeStreamTubeInterface(
03674         const QDBusConnection& connection,
03675         const QString& busName,
03676         const QString& objectPath,
03677         QObject* parent = 0
03678     );
03679 
03686     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
03687 
03695     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
03696 
03704     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03705 
03722     Q_PROPERTY(QString Service READ Service)
03723 
03724     
03732     inline QString Service() const TELEPATHY_GNUC_DEPRECATED
03733     {
03734         return qvariant_cast<QString>(internalPropGet("Service"));
03735     }
03736 
03765     Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)
03766 
03767     
03775     inline Tp::SupportedSocketMap SupportedSocketTypes() const TELEPATHY_GNUC_DEPRECATED
03776     {
03777         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
03778     }
03779 
03780 public Q_SLOTS:
03806     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
03807     {
03808         if (!invalidationReason().isEmpty()) {
03809             return QDBusPendingReply<>(QDBusMessage::createError(
03810                 invalidationReason(),
03811                 invalidationMessage()
03812             ));
03813         }
03814 
03815 
03816         QList<QVariant> argumentList;
03817         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
03818         return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
03819     }
03820 
03854     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
03855     {
03856         if (!invalidationReason().isEmpty()) {
03857             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03858                 invalidationReason(),
03859                 invalidationMessage()
03860             ));
03861         }
03862 
03863 
03864         QList<QVariant> argumentList;
03865         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
03866         return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
03867     }
03868 
03869 Q_SIGNALS:
03906     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
03907 
03921     void NewLocalConnection(uint connectionID);
03922 
03950     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
03951 
03952 protected:
03953     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03954 };
03955 
03963 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
03964 {
03965     Q_OBJECT
03966 
03967 public:
03974     static inline const char *staticInterfaceName()
03975     {
03976         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
03977     }
03978 
03986     ChannelTypeStreamedMediaInterface(
03987         const QString& busName,
03988         const QString& objectPath,
03989         QObject* parent = 0
03990     );
03991 
04000     ChannelTypeStreamedMediaInterface(
04001         const QDBusConnection& connection,
04002         const QString& busName,
04003         const QString& objectPath,
04004         QObject* parent = 0
04005     );
04006 
04013     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
04014 
04022     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
04023 
04031     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04032 
04115     Q_PROPERTY(bool InitialAudio READ InitialAudio)
04116 
04117     
04125     inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
04126     {
04127         return qvariant_cast<bool>(internalPropGet("InitialAudio"));
04128     }
04129 
04144     Q_PROPERTY(bool InitialVideo READ InitialVideo)
04145 
04146     
04154     inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
04155     {
04156         return qvariant_cast<bool>(internalPropGet("InitialVideo"));
04157     }
04158 
04195     Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)
04196 
04197     
04205     inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
04206     {
04207         return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
04208     }
04209 
04210 public Q_SLOTS:
04231     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
04232     {
04233         if (!invalidationReason().isEmpty()) {
04234             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
04235                 invalidationReason(),
04236                 invalidationMessage()
04237             ));
04238         }
04239 
04240 
04241         return asyncCall(QLatin1String("ListStreams"));
04242     }
04243 
04263     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
04264     {
04265         if (!invalidationReason().isEmpty()) {
04266             return QDBusPendingReply<>(QDBusMessage::createError(
04267                 invalidationReason(),
04268                 invalidationMessage()
04269             ));
04270         }
04271 
04272 
04273         QList<QVariant> argumentList;
04274         argumentList << QVariant::fromValue(streams);
04275         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
04276     }
04277 
04307     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
04308     {
04309         if (!invalidationReason().isEmpty()) {
04310             return QDBusPendingReply<>(QDBusMessage::createError(
04311                 invalidationReason(),
04312                 invalidationMessage()
04313             ));
04314         }
04315 
04316 
04317         QList<QVariant> argumentList;
04318         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
04319         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
04320     }
04321 
04365     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
04366     {
04367         if (!invalidationReason().isEmpty()) {
04368             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
04369                 invalidationReason(),
04370                 invalidationMessage()
04371             ));
04372         }
04373 
04374 
04375         QList<QVariant> argumentList;
04376         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
04377         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
04378     }
04379 
04380 Q_SIGNALS:
04445     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
04446 
04476     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
04477 
04495     void StreamError(uint streamID, uint errorCode, const QString& message);
04496 
04506     void StreamRemoved(uint streamID);
04507 
04521     void StreamStateChanged(uint streamID, uint streamState);
04522 
04523 protected:
04524     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04525 };
04526 
04534 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
04535 {
04536     Q_OBJECT
04537 
04538 public:
04545     static inline const char *staticInterfaceName()
04546     {
04547         return "org.freedesktop.Telepathy.Channel.Type.Text";
04548     }
04549 
04557     ChannelTypeTextInterface(
04558         const QString& busName,
04559         const QString& objectPath,
04560         QObject* parent = 0
04561     );
04562 
04571     ChannelTypeTextInterface(
04572         const QDBusConnection& connection,
04573         const QString& busName,
04574         const QString& objectPath,
04575         QObject* parent = 0
04576     );
04577 
04584     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
04585 
04593     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
04594 
04602     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04603 
04604 public Q_SLOTS:
04615     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
04616     {
04617         if (!invalidationReason().isEmpty()) {
04618             return QDBusPendingReply<>(QDBusMessage::createError(
04619                 invalidationReason(),
04620                 invalidationMessage()
04621             ));
04622         }
04623 
04624 
04625         QList<QVariant> argumentList;
04626         argumentList << QVariant::fromValue(IDs);
04627         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
04628     }
04629 
04640     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
04641     {
04642         if (!invalidationReason().isEmpty()) {
04643             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
04644                 invalidationReason(),
04645                 invalidationMessage()
04646             ));
04647         }
04648 
04649 
04650         return asyncCall(QLatin1String("GetMessageTypes"));
04651     }
04652 
04676     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
04677     {
04678         if (!invalidationReason().isEmpty()) {
04679             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
04680                 invalidationReason(),
04681                 invalidationMessage()
04682             ));
04683         }
04684 
04685 
04686         QList<QVariant> argumentList;
04687         argumentList << QVariant::fromValue(clear);
04688         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
04689     }
04690 
04716     inline QDBusPendingReply<> Send(uint type, const QString& text)
04717     {
04718         if (!invalidationReason().isEmpty()) {
04719             return QDBusPendingReply<>(QDBusMessage::createError(
04720                 invalidationReason(),
04721                 invalidationMessage()
04722             ));
04723         }
04724 
04725 
04726         QList<QVariant> argumentList;
04727         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
04728         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
04729     }
04730 
04731 Q_SIGNALS:
04739     void LostMessage();
04740 
04774     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
04775 
04802     void SendError(uint error, uint timestamp, uint type, const QString& text);
04803 
04825     void Sent(uint timestamp, uint type, const QString& text);
04826 
04827 protected:
04828     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04829 };
04830 
04838 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
04839 {
04840     Q_OBJECT
04841 
04842 public:
04849     static inline const char *staticInterfaceName()
04850     {
04851         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
04852     }
04853 
04861     ChannelTypeTubesInterface(
04862         const QString& busName,
04863         const QString& objectPath,
04864         QObject* parent = 0
04865     );
04866 
04875     ChannelTypeTubesInterface(
04876         const QDBusConnection& connection,
04877         const QString& busName,
04878         const QString& objectPath,
04879         QObject* parent = 0
04880     );
04881 
04888     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
04889 
04897     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
04898 
04906     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04907 
04908 public Q_SLOTS:
04938     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
04939     {
04940         if (!invalidationReason().isEmpty()) {
04941             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
04942                 invalidationReason(),
04943                 invalidationMessage()
04944             ));
04945         }
04946 
04947 
04948         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
04949     }
04950 
04959     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
04960     {
04961         if (!invalidationReason().isEmpty()) {
04962             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
04963                 invalidationReason(),
04964                 invalidationMessage()
04965             ));
04966         }
04967 
04968 
04969         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
04970     }
04971 
04982     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
04983     {
04984         if (!invalidationReason().isEmpty()) {
04985             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
04986                 invalidationReason(),
04987                 invalidationMessage()
04988             ));
04989         }
04990 
04991 
04992         return asyncCall(QLatin1String("ListTubes"));
04993     }
04994 
05017     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
05018     {
05019         if (!invalidationReason().isEmpty()) {
05020             return QDBusPendingReply<uint>(QDBusMessage::createError(
05021                 invalidationReason(),
05022                 invalidationMessage()
05023             ));
05024         }
05025 
05026 
05027         QList<QVariant> argumentList;
05028         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
05029         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
05030     }
05031 
05082     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
05083     {
05084         if (!invalidationReason().isEmpty()) {
05085             return QDBusPendingReply<uint>(QDBusMessage::createError(
05086                 invalidationReason(),
05087                 invalidationMessage()
05088             ));
05089         }
05090 
05091 
05092         QList<QVariant> argumentList;
05093         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05094         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
05095     }
05096 
05114     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
05115     {
05116         if (!invalidationReason().isEmpty()) {
05117             return QDBusPendingReply<QString>(QDBusMessage::createError(
05118                 invalidationReason(),
05119                 invalidationMessage()
05120             ));
05121         }
05122 
05123 
05124         QList<QVariant> argumentList;
05125         argumentList << QVariant::fromValue(ID);
05126         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
05127     }
05128 
05161     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
05162     {
05163         if (!invalidationReason().isEmpty()) {
05164             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05165                 invalidationReason(),
05166                 invalidationMessage()
05167             ));
05168         }
05169 
05170 
05171         QList<QVariant> argumentList;
05172         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05173         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
05174     }
05175 
05185     inline QDBusPendingReply<> CloseTube(uint ID)
05186     {
05187         if (!invalidationReason().isEmpty()) {
05188             return QDBusPendingReply<>(QDBusMessage::createError(
05189                 invalidationReason(),
05190                 invalidationMessage()
05191             ));
05192         }
05193 
05194 
05195         QList<QVariant> argumentList;
05196         argumentList << QVariant::fromValue(ID);
05197         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
05198     }
05199 
05214     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
05215     {
05216         if (!invalidationReason().isEmpty()) {
05217             return QDBusPendingReply<QString>(QDBusMessage::createError(
05218                 invalidationReason(),
05219                 invalidationMessage()
05220             ));
05221         }
05222 
05223 
05224         QList<QVariant> argumentList;
05225         argumentList << QVariant::fromValue(ID);
05226         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
05227     }
05228 
05244     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
05245     {
05246         if (!invalidationReason().isEmpty()) {
05247             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
05248                 invalidationReason(),
05249                 invalidationMessage()
05250             ));
05251         }
05252 
05253 
05254         QList<QVariant> argumentList;
05255         argumentList << QVariant::fromValue(ID);
05256         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
05257     }
05258 
05279     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
05280     {
05281         if (!invalidationReason().isEmpty()) {
05282             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
05283                 invalidationReason(),
05284                 invalidationMessage()
05285             ));
05286         }
05287 
05288 
05289         QList<QVariant> argumentList;
05290         argumentList << QVariant::fromValue(ID);
05291         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
05292     }
05293 
05294 Q_SIGNALS:
05324     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
05325 
05339     void TubeStateChanged(uint ID, uint state);
05340 
05351     void TubeClosed(uint ID);
05352 
05371     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
05372 
05387     void StreamTubeNewConnection(uint ID, uint handle);
05388 
05389 protected:
05390     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05391 };
05392 }
05393 }
05394 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
05395 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
05396 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
05397 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
05398 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
05399 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
05400 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
05401 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
05402 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
05403 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
05404 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
05405 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
05406 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
05407 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
05408 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
05409 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
05410 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


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