00001
00002
00003
00004
00005
00006
00007
00008 #ifndef IN_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011
00012 #include <TelepathyQt4/Types>
00013
00014 #include <QtGlobal>
00015
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019
00020 #include <QDBusPendingReply>
00021
00022 #include <TelepathyQt4/Client/AbstractInterface>
00023 #include <TelepathyQt4/Client/DBusProxy>
00024
00025
00026 #ifndef TELEPATHY_GNUC_DEPRECATED
00027 # if defined(Q_CC_GNUC) && __GNUC__ >= 4
00028 # define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
00029 # else
00030 # define TELEPATHY_GNUC_DEPRECATED
00031 # endif
00032 #endif
00033 namespace Telepathy
00034 {
00035 namespace Client
00036 {
00037
00045 class ChannelInterface : public Telepathy::Client::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& serviceName,
00070 const QString& objectPath,
00071 QObject* parent = 0
00072 );
00073
00082 ChannelInterface(
00083 const QDBusConnection& connection,
00084 const QString& serviceName,
00085 const QString& objectPath,
00086 QObject* parent = 0
00087 );
00088
00095 ChannelInterface(Telepathy::Client::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(Telepathy::Client::DBusProxy *, const QString &, const QString &);
00600 };
00601
00609 class ChannelInterfaceCallStateInterface : public Telepathy::Client::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& serviceName,
00634 const QString& objectPath,
00635 QObject* parent = 0
00636 );
00637
00646 ChannelInterfaceCallStateInterface(
00647 const QDBusConnection& connection,
00648 const QString& serviceName,
00649 const QString& objectPath,
00650 QObject* parent = 0
00651 );
00652
00659 ChannelInterfaceCallStateInterface(Telepathy::Client::DBusProxy *proxy);
00660
00668 explicit ChannelInterfaceCallStateInterface(const Telepathy::Client::ChannelInterface& mainInterface);
00669
00677 ChannelInterfaceCallStateInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
00678
00679 public Q_SLOTS:
00690 inline QDBusPendingReply<Telepathy::ChannelCallStateMap> GetCallStates()
00691 {
00692 if (!invalidationReason().isEmpty()) {
00693 return QDBusPendingReply<Telepathy::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(Telepathy::Client::DBusProxy *, const QString &, const QString &);
00721 };
00722
00730 class ChannelInterfaceChatStateInterface : public Telepathy::Client::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& serviceName,
00755 const QString& objectPath,
00756 QObject* parent = 0
00757 );
00758
00767 ChannelInterfaceChatStateInterface(
00768 const QDBusConnection& connection,
00769 const QString& serviceName,
00770 const QString& objectPath,
00771 QObject* parent = 0
00772 );
00773
00780 ChannelInterfaceChatStateInterface(Telepathy::Client::DBusProxy *proxy);
00781
00789 explicit ChannelInterfaceChatStateInterface(const Telepathy::Client::ChannelInterface& mainInterface);
00790
00798 ChannelInterfaceChatStateInterface(const Telepathy::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(Telepathy::Client::DBusProxy *, const QString &, const QString &);
00845 };
00846
00854 class ChannelInterfaceDTMFInterface : public Telepathy::Client::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& serviceName,
00879 const QString& objectPath,
00880 QObject* parent = 0
00881 );
00882
00891 ChannelInterfaceDTMFInterface(
00892 const QDBusConnection& connection,
00893 const QString& serviceName,
00894 const QString& objectPath,
00895 QObject* parent = 0
00896 );
00897
00904 ChannelInterfaceDTMFInterface(Telepathy::Client::DBusProxy *proxy);
00905
00913 explicit ChannelInterfaceDTMFInterface(const Telepathy::Client::ChannelInterface& mainInterface);
00914
00922 ChannelInterfaceDTMFInterface(const Telepathy::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(Telepathy::Client::DBusProxy *, const QString &, const QString &);
00984 };
00985
00993 class ChannelInterfaceGroupInterface : public Telepathy::Client::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& serviceName,
01018 const QString& objectPath,
01019 QObject* parent = 0
01020 );
01021
01030 ChannelInterfaceGroupInterface(
01031 const QDBusConnection& connection,
01032 const QString& serviceName,
01033 const QString& objectPath,
01034 QObject* parent = 0
01035 );
01036
01043 ChannelInterfaceGroupInterface(Telepathy::Client::DBusProxy *proxy);
01044
01052 explicit ChannelInterfaceGroupInterface(const Telepathy::Client::ChannelInterface& mainInterface);
01053
01061 ChannelInterfaceGroupInterface(const Telepathy::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(Telepathy::HandleOwnerMap HandleOwners READ HandleOwners)
01098
01099
01107 inline Telepathy::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
01108 {
01109 return qvariant_cast<Telepathy::HandleOwnerMap>(internalPropGet("HandleOwners"));
01110 }
01111
01118 Q_PROPERTY(Telepathy::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
01119
01120
01128 inline Telepathy::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
01129 {
01130 return qvariant_cast<Telepathy::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
01131 }
01132
01138 Q_PROPERTY(Telepathy::UIntList Members READ Members)
01139
01140
01148 inline Telepathy::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
01149 {
01150 return qvariant_cast<Telepathy::UIntList>(internalPropGet("Members"));
01151 }
01152
01159 Q_PROPERTY(Telepathy::UIntList RemotePendingMembers READ RemotePendingMembers)
01160
01161
01169 inline Telepathy::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
01170 {
01171 return qvariant_cast<Telepathy::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 Telepathy::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<Telepathy::UIntList, Telepathy::UIntList, Telepathy::UIntList> GetAllMembers()
01256 {
01257 if (!invalidationReason().isEmpty()) {
01258 return QDBusPendingReply<Telepathy::UIntList, Telepathy::UIntList, Telepathy::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<Telepathy::UIntList> GetHandleOwners(const Telepathy::UIntList& handles)
01311 {
01312 if (!invalidationReason().isEmpty()) {
01313 return QDBusPendingReply<Telepathy::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<Telepathy::UIntList> GetLocalPendingMembers()
01332 {
01333 if (!invalidationReason().isEmpty()) {
01334 return QDBusPendingReply<Telepathy::UIntList>(QDBusMessage::createError(
01335 invalidationReason(),
01336 invalidationMessage()
01337 ));
01338 }
01339
01340
01341 return asyncCall(QLatin1String("GetLocalPendingMembers"));
01342 }
01343
01357 inline QDBusPendingReply<Telepathy::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
01358 {
01359 if (!invalidationReason().isEmpty()) {
01360 return QDBusPendingReply<Telepathy::LocalPendingInfoList>(QDBusMessage::createError(
01361 invalidationReason(),
01362 invalidationMessage()
01363 ));
01364 }
01365
01366
01367 return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
01368 }
01369
01375 inline QDBusPendingReply<Telepathy::UIntList> GetMembers()
01376 {
01377 if (!invalidationReason().isEmpty()) {
01378 return QDBusPendingReply<Telepathy::UIntList>(QDBusMessage::createError(
01379 invalidationReason(),
01380 invalidationMessage()
01381 ));
01382 }
01383
01384
01385 return asyncCall(QLatin1String("GetMembers"));
01386 }
01387
01394 inline QDBusPendingReply<Telepathy::UIntList> GetRemotePendingMembers()
01395 {
01396 if (!invalidationReason().isEmpty()) {
01397 return QDBusPendingReply<Telepathy::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
01445 inline QDBusPendingReply<> RemoveMembers(const Telepathy::UIntList& contacts, const QString& message)
01446 {
01447 if (!invalidationReason().isEmpty()) {
01448 return QDBusPendingReply<>(QDBusMessage::createError(
01449 invalidationReason(),
01450 invalidationMessage()
01451 ));
01452 }
01453
01454
01455 QList<QVariant> argumentList;
01456 argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01457 return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
01458 }
01459
01479 inline QDBusPendingReply<> RemoveMembersWithReason(const Telepathy::UIntList& contacts, const QString& message, uint reason)
01480 {
01481 if (!invalidationReason().isEmpty()) {
01482 return QDBusPendingReply<>(QDBusMessage::createError(
01483 invalidationReason(),
01484 invalidationMessage()
01485 ));
01486 }
01487
01488
01489 QList<QVariant> argumentList;
01490 argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
01491 return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
01492 }
01493
01494 Q_SIGNALS:
01513 void HandleOwnersChanged(const Telepathy::HandleOwnerMap& added, const Telepathy::UIntList& removed);
01514
01524 void SelfHandleChanged(uint selfHandle);
01525
01540 void GroupFlagsChanged(uint added, uint removed);
01541
01589 void MembersChanged(const QString& message, const Telepathy::UIntList& added, const Telepathy::UIntList& removed, const Telepathy::UIntList& localPending, const Telepathy::UIntList& remotePending, uint actor, uint reason);
01590
01691 void MembersChangedDetailed(const Telepathy::UIntList& added, const Telepathy::UIntList& removed, const Telepathy::UIntList& localPending, const Telepathy::UIntList& remotePending, const QVariantMap& details);
01692
01693 protected:
01694 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
01695 };
01696
01704 class ChannelInterfaceHoldInterface : public Telepathy::Client::AbstractInterface
01705 {
01706 Q_OBJECT
01707
01708 public:
01715 static inline const char *staticInterfaceName()
01716 {
01717 return "org.freedesktop.Telepathy.Channel.Interface.Hold";
01718 }
01719
01727 ChannelInterfaceHoldInterface(
01728 const QString& serviceName,
01729 const QString& objectPath,
01730 QObject* parent = 0
01731 );
01732
01741 ChannelInterfaceHoldInterface(
01742 const QDBusConnection& connection,
01743 const QString& serviceName,
01744 const QString& objectPath,
01745 QObject* parent = 0
01746 );
01747
01754 ChannelInterfaceHoldInterface(Telepathy::Client::DBusProxy *proxy);
01755
01763 explicit ChannelInterfaceHoldInterface(const Telepathy::Client::ChannelInterface& mainInterface);
01764
01772 ChannelInterfaceHoldInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
01773
01774 public Q_SLOTS:
01788 inline QDBusPendingReply<uint, uint> GetHoldState()
01789 {
01790 if (!invalidationReason().isEmpty()) {
01791 return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
01792 invalidationReason(),
01793 invalidationMessage()
01794 ));
01795 }
01796
01797
01798 return asyncCall(QLatin1String("GetHoldState"));
01799 }
01800
01857 inline QDBusPendingReply<> RequestHold(bool hold)
01858 {
01859 if (!invalidationReason().isEmpty()) {
01860 return QDBusPendingReply<>(QDBusMessage::createError(
01861 invalidationReason(),
01862 invalidationMessage()
01863 ));
01864 }
01865
01866
01867 QList<QVariant> argumentList;
01868 argumentList << QVariant::fromValue(hold);
01869 return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
01870 }
01871
01872 Q_SIGNALS:
01889 void HoldStateChanged(uint holdState, uint reason);
01890
01891 protected:
01892 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
01893 };
01894
01902 class ChannelInterfaceMediaSignallingInterface : public Telepathy::Client::AbstractInterface
01903 {
01904 Q_OBJECT
01905
01906 public:
01913 static inline const char *staticInterfaceName()
01914 {
01915 return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
01916 }
01917
01925 ChannelInterfaceMediaSignallingInterface(
01926 const QString& serviceName,
01927 const QString& objectPath,
01928 QObject* parent = 0
01929 );
01930
01939 ChannelInterfaceMediaSignallingInterface(
01940 const QDBusConnection& connection,
01941 const QString& serviceName,
01942 const QString& objectPath,
01943 QObject* parent = 0
01944 );
01945
01952 ChannelInterfaceMediaSignallingInterface(Telepathy::Client::DBusProxy *proxy);
01953
01961 explicit ChannelInterfaceMediaSignallingInterface(const Telepathy::Client::ChannelInterface& mainInterface);
01962
01970 ChannelInterfaceMediaSignallingInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
01971
01972 public Q_SLOTS:
01979 inline QDBusPendingReply<Telepathy::MediaSessionHandlerInfoList> GetSessionHandlers()
01980 {
01981 if (!invalidationReason().isEmpty()) {
01982 return QDBusPendingReply<Telepathy::MediaSessionHandlerInfoList>(QDBusMessage::createError(
01983 invalidationReason(),
01984 invalidationMessage()
01985 ));
01986 }
01987
01988
01989 return asyncCall(QLatin1String("GetSessionHandlers"));
01990 }
01991
01992 Q_SIGNALS:
02008 void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02009
02010 protected:
02011 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
02012 };
02013
02021 class ChannelInterfaceMessagesInterface : public Telepathy::Client::AbstractInterface
02022 {
02023 Q_OBJECT
02024
02025 public:
02032 static inline const char *staticInterfaceName()
02033 {
02034 return "org.freedesktop.Telepathy.Channel.Interface.Messages";
02035 }
02036
02044 ChannelInterfaceMessagesInterface(
02045 const QString& serviceName,
02046 const QString& objectPath,
02047 QObject* parent = 0
02048 );
02049
02058 ChannelInterfaceMessagesInterface(
02059 const QDBusConnection& connection,
02060 const QString& serviceName,
02061 const QString& objectPath,
02062 QObject* parent = 0
02063 );
02064
02071 ChannelInterfaceMessagesInterface(Telepathy::Client::DBusProxy *proxy);
02072
02080 explicit ChannelInterfaceMessagesInterface(const Telepathy::Client::ChannelInterface& mainInterface);
02081
02089 ChannelInterfaceMessagesInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
02090
02136 Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
02137
02138
02146 inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
02147 {
02148 return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
02149 }
02150
02156 Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
02157
02158
02166 inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
02167 {
02168 return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
02169 }
02170
02180 Q_PROPERTY(Telepathy::MessagePartListList PendingMessages READ PendingMessages)
02181
02182
02190 inline Telepathy::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
02191 {
02192 return qvariant_cast<Telepathy::MessagePartListList>(internalPropGet("PendingMessages"));
02193 }
02194
02200 Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
02201
02202
02210 inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
02211 {
02212 return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
02213 }
02214
02215 public Q_SLOTS:
02255 inline QDBusPendingReply<QString> SendMessage(const Telepathy::MessagePartList& message, uint flags)
02256 {
02257 if (!invalidationReason().isEmpty()) {
02258 return QDBusPendingReply<QString>(QDBusMessage::createError(
02259 invalidationReason(),
02260 invalidationMessage()
02261 ));
02262 }
02263
02264
02265 QList<QVariant> argumentList;
02266 argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
02267 return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
02268 }
02269
02303 inline QDBusPendingReply<Telepathy::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Telepathy::UIntList& parts)
02304 {
02305 if (!invalidationReason().isEmpty()) {
02306 return QDBusPendingReply<Telepathy::MessagePartContentMap>(QDBusMessage::createError(
02307 invalidationReason(),
02308 invalidationMessage()
02309 ));
02310 }
02311
02312
02313 QList<QVariant> argumentList;
02314 argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
02315 return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
02316 }
02317
02318 Q_SIGNALS:
02364 void MessageSent(const Telepathy::MessagePartList& content, uint flags, const QString& messageToken);
02365
02379 void PendingMessagesRemoved(const Telepathy::UIntList& messageIDs);
02380
02395 void MessageReceived(const Telepathy::MessagePartList& message);
02396
02397 protected:
02398 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
02399 };
02400
02408 class ChannelInterfacePasswordInterface : public Telepathy::Client::AbstractInterface
02409 {
02410 Q_OBJECT
02411
02412 public:
02419 static inline const char *staticInterfaceName()
02420 {
02421 return "org.freedesktop.Telepathy.Channel.Interface.Password";
02422 }
02423
02431 ChannelInterfacePasswordInterface(
02432 const QString& serviceName,
02433 const QString& objectPath,
02434 QObject* parent = 0
02435 );
02436
02445 ChannelInterfacePasswordInterface(
02446 const QDBusConnection& connection,
02447 const QString& serviceName,
02448 const QString& objectPath,
02449 QObject* parent = 0
02450 );
02451
02458 ChannelInterfacePasswordInterface(Telepathy::Client::DBusProxy *proxy);
02459
02467 explicit ChannelInterfacePasswordInterface(const Telepathy::Client::ChannelInterface& mainInterface);
02468
02476 ChannelInterfacePasswordInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
02477
02478 public Q_SLOTS:
02491 inline QDBusPendingReply<uint> GetPasswordFlags()
02492 {
02493 if (!invalidationReason().isEmpty()) {
02494 return QDBusPendingReply<uint>(QDBusMessage::createError(
02495 invalidationReason(),
02496 invalidationMessage()
02497 ));
02498 }
02499
02500
02501 return asyncCall(QLatin1String("GetPasswordFlags"));
02502 }
02503
02515 inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
02516 {
02517 if (!invalidationReason().isEmpty()) {
02518 return QDBusPendingReply<bool>(QDBusMessage::createError(
02519 invalidationReason(),
02520 invalidationMessage()
02521 ));
02522 }
02523
02524
02525 QList<QVariant> argumentList;
02526 argumentList << QVariant::fromValue(password);
02527 return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
02528 }
02529
02530 Q_SIGNALS:
02545 void PasswordFlagsChanged(uint added, uint removed);
02546
02547 protected:
02548 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
02549 };
02550
02558 class ChannelTypeContactListInterface : public Telepathy::Client::AbstractInterface
02559 {
02560 Q_OBJECT
02561
02562 public:
02569 static inline const char *staticInterfaceName()
02570 {
02571 return "org.freedesktop.Telepathy.Channel.Type.ContactList";
02572 }
02573
02581 ChannelTypeContactListInterface(
02582 const QString& serviceName,
02583 const QString& objectPath,
02584 QObject* parent = 0
02585 );
02586
02595 ChannelTypeContactListInterface(
02596 const QDBusConnection& connection,
02597 const QString& serviceName,
02598 const QString& objectPath,
02599 QObject* parent = 0
02600 );
02601
02608 ChannelTypeContactListInterface(Telepathy::Client::DBusProxy *proxy);
02609
02617 explicit ChannelTypeContactListInterface(const Telepathy::Client::ChannelInterface& mainInterface);
02618
02626 ChannelTypeContactListInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
02627
02628 protected:
02629 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
02630 };
02631
02639 class ChannelTypeFileTransferInterface : public Telepathy::Client::AbstractInterface
02640 {
02641 Q_OBJECT
02642
02643 public:
02650 static inline const char *staticInterfaceName()
02651 {
02652 return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
02653 }
02654
02662 ChannelTypeFileTransferInterface(
02663 const QString& serviceName,
02664 const QString& objectPath,
02665 QObject* parent = 0
02666 );
02667
02676 ChannelTypeFileTransferInterface(
02677 const QDBusConnection& connection,
02678 const QString& serviceName,
02679 const QString& objectPath,
02680 QObject* parent = 0
02681 );
02682
02689 ChannelTypeFileTransferInterface(Telepathy::Client::DBusProxy *proxy);
02690
02698 explicit ChannelTypeFileTransferInterface(const Telepathy::Client::ChannelInterface& mainInterface);
02699
02707 ChannelTypeFileTransferInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
02708
02715 Q_PROPERTY(uint State READ State)
02716
02717
02725 inline uint State() const TELEPATHY_GNUC_DEPRECATED
02726 {
02727 return qvariant_cast<uint>(internalPropGet("State"));
02728 }
02729
02741 Q_PROPERTY(QString ContentType READ ContentType)
02742
02743
02751 inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
02752 {
02753 return qvariant_cast<QString>(internalPropGet("ContentType"));
02754 }
02755
02771 Q_PROPERTY(QString Filename READ Filename)
02772
02773
02781 inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
02782 {
02783 return qvariant_cast<QString>(internalPropGet("Filename"));
02784 }
02785
02803 Q_PROPERTY(qulonglong Size READ Size)
02804
02805
02813 inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
02814 {
02815 return qvariant_cast<qulonglong>(internalPropGet("Size"));
02816 }
02817
02830 Q_PROPERTY(uint ContentHashType READ ContentHashType)
02831
02832
02840 inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
02841 {
02842 return qvariant_cast<uint>(internalPropGet("ContentHashType"));
02843 }
02844
02859 Q_PROPERTY(QString ContentHash READ ContentHash)
02860
02861
02869 inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
02870 {
02871 return qvariant_cast<QString>(internalPropGet("ContentHash"));
02872 }
02873
02885 Q_PROPERTY(QString Description READ Description)
02886
02887
02895 inline QString Description() const TELEPATHY_GNUC_DEPRECATED
02896 {
02897 return qvariant_cast<QString>(internalPropGet("Description"));
02898 }
02899
02910 Q_PROPERTY(qlonglong Date READ Date)
02911
02912
02920 inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
02921 {
02922 return qvariant_cast<qlonglong>(internalPropGet("Date"));
02923 }
02924
02947 Q_PROPERTY(Telepathy::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
02948
02949
02957 inline Telepathy::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
02958 {
02959 return qvariant_cast<Telepathy::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
02960 }
02961
02969 Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
02970
02971
02979 inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
02980 {
02981 return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
02982 }
02983
03000 Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
03001
03002
03010 inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
03011 {
03012 return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
03013 }
03014
03015 public Q_SLOTS:
03055 inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
03056 {
03057 if (!invalidationReason().isEmpty()) {
03058 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03059 invalidationReason(),
03060 invalidationMessage()
03061 ));
03062 }
03063
03064
03065 QList<QVariant> argumentList;
03066 argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
03067 return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
03068 }
03069
03098 inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
03099 {
03100 if (!invalidationReason().isEmpty()) {
03101 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03102 invalidationReason(),
03103 invalidationMessage()
03104 ));
03105 }
03106
03107
03108 QList<QVariant> argumentList;
03109 argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
03110 return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
03111 }
03112
03113 Q_SIGNALS:
03131 void FileTransferStateChanged(uint state, uint reason);
03132
03145 void TransferredBytesChanged(qulonglong count);
03146
03158 void InitialOffsetDefined(qulonglong initialOffset);
03159
03160 protected:
03161 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
03162 };
03163
03171 class ChannelTypeRoomListInterface : public Telepathy::Client::AbstractInterface
03172 {
03173 Q_OBJECT
03174
03175 public:
03182 static inline const char *staticInterfaceName()
03183 {
03184 return "org.freedesktop.Telepathy.Channel.Type.RoomList";
03185 }
03186
03194 ChannelTypeRoomListInterface(
03195 const QString& serviceName,
03196 const QString& objectPath,
03197 QObject* parent = 0
03198 );
03199
03208 ChannelTypeRoomListInterface(
03209 const QDBusConnection& connection,
03210 const QString& serviceName,
03211 const QString& objectPath,
03212 QObject* parent = 0
03213 );
03214
03221 ChannelTypeRoomListInterface(Telepathy::Client::DBusProxy *proxy);
03222
03230 explicit ChannelTypeRoomListInterface(const Telepathy::Client::ChannelInterface& mainInterface);
03231
03239 ChannelTypeRoomListInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
03240
03250 Q_PROPERTY(QString Server READ Server)
03251
03252
03260 inline QString Server() const TELEPATHY_GNUC_DEPRECATED
03261 {
03262 return qvariant_cast<QString>(internalPropGet("Server"));
03263 }
03264
03265 public Q_SLOTS:
03276 inline QDBusPendingReply<bool> GetListingRooms()
03277 {
03278 if (!invalidationReason().isEmpty()) {
03279 return QDBusPendingReply<bool>(QDBusMessage::createError(
03280 invalidationReason(),
03281 invalidationMessage()
03282 ));
03283 }
03284
03285
03286 return asyncCall(QLatin1String("GetListingRooms"));
03287 }
03288
03297 inline QDBusPendingReply<> ListRooms()
03298 {
03299 if (!invalidationReason().isEmpty()) {
03300 return QDBusPendingReply<>(QDBusMessage::createError(
03301 invalidationReason(),
03302 invalidationMessage()
03303 ));
03304 }
03305
03306
03307 return asyncCall(QLatin1String("ListRooms"));
03308 }
03309
03317 inline QDBusPendingReply<> StopListing()
03318 {
03319 if (!invalidationReason().isEmpty()) {
03320 return QDBusPendingReply<>(QDBusMessage::createError(
03321 invalidationReason(),
03322 invalidationMessage()
03323 ));
03324 }
03325
03326
03327 return asyncCall(QLatin1String("StopListing"));
03328 }
03329
03330 Q_SIGNALS:
03375 void GotRooms(const Telepathy::RoomInfoList& rooms);
03376
03387 void ListingRooms(bool listing);
03388
03389 protected:
03390 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
03391 };
03392
03400 class ChannelTypeStreamedMediaInterface : public Telepathy::Client::AbstractInterface
03401 {
03402 Q_OBJECT
03403
03404 public:
03411 static inline const char *staticInterfaceName()
03412 {
03413 return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
03414 }
03415
03423 ChannelTypeStreamedMediaInterface(
03424 const QString& serviceName,
03425 const QString& objectPath,
03426 QObject* parent = 0
03427 );
03428
03437 ChannelTypeStreamedMediaInterface(
03438 const QDBusConnection& connection,
03439 const QString& serviceName,
03440 const QString& objectPath,
03441 QObject* parent = 0
03442 );
03443
03450 ChannelTypeStreamedMediaInterface(Telepathy::Client::DBusProxy *proxy);
03451
03459 explicit ChannelTypeStreamedMediaInterface(const Telepathy::Client::ChannelInterface& mainInterface);
03460
03468 ChannelTypeStreamedMediaInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
03469
03470 public Q_SLOTS:
03491 inline QDBusPendingReply<Telepathy::MediaStreamInfoList> ListStreams()
03492 {
03493 if (!invalidationReason().isEmpty()) {
03494 return QDBusPendingReply<Telepathy::MediaStreamInfoList>(QDBusMessage::createError(
03495 invalidationReason(),
03496 invalidationMessage()
03497 ));
03498 }
03499
03500
03501 return asyncCall(QLatin1String("ListStreams"));
03502 }
03503
03513 inline QDBusPendingReply<> RemoveStreams(const Telepathy::UIntList& streams)
03514 {
03515 if (!invalidationReason().isEmpty()) {
03516 return QDBusPendingReply<>(QDBusMessage::createError(
03517 invalidationReason(),
03518 invalidationMessage()
03519 ));
03520 }
03521
03522
03523 QList<QVariant> argumentList;
03524 argumentList << QVariant::fromValue(streams);
03525 return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
03526 }
03527
03557 inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
03558 {
03559 if (!invalidationReason().isEmpty()) {
03560 return QDBusPendingReply<>(QDBusMessage::createError(
03561 invalidationReason(),
03562 invalidationMessage()
03563 ));
03564 }
03565
03566
03567 QList<QVariant> argumentList;
03568 argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
03569 return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
03570 }
03571
03612 inline QDBusPendingReply<Telepathy::MediaStreamInfoList> RequestStreams(uint contactHandle, const Telepathy::UIntList& types)
03613 {
03614 if (!invalidationReason().isEmpty()) {
03615 return QDBusPendingReply<Telepathy::MediaStreamInfoList>(QDBusMessage::createError(
03616 invalidationReason(),
03617 invalidationMessage()
03618 ));
03619 }
03620
03621
03622 QList<QVariant> argumentList;
03623 argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
03624 return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
03625 }
03626
03627 Q_SIGNALS:
03646 void StreamAdded(uint streamID, uint contactHandle, uint streamType);
03647
03668 void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
03669
03687 void StreamError(uint streamID, uint errorCode, const QString& message);
03688
03698 void StreamRemoved(uint streamID);
03699
03713 void StreamStateChanged(uint streamID, uint streamState);
03714
03715 protected:
03716 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
03717 };
03718
03726 class ChannelTypeTextInterface : public Telepathy::Client::AbstractInterface
03727 {
03728 Q_OBJECT
03729
03730 public:
03737 static inline const char *staticInterfaceName()
03738 {
03739 return "org.freedesktop.Telepathy.Channel.Type.Text";
03740 }
03741
03749 ChannelTypeTextInterface(
03750 const QString& serviceName,
03751 const QString& objectPath,
03752 QObject* parent = 0
03753 );
03754
03763 ChannelTypeTextInterface(
03764 const QDBusConnection& connection,
03765 const QString& serviceName,
03766 const QString& objectPath,
03767 QObject* parent = 0
03768 );
03769
03776 ChannelTypeTextInterface(Telepathy::Client::DBusProxy *proxy);
03777
03785 explicit ChannelTypeTextInterface(const Telepathy::Client::ChannelInterface& mainInterface);
03786
03794 ChannelTypeTextInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
03795
03796 public Q_SLOTS:
03807 inline QDBusPendingReply<> AcknowledgePendingMessages(const Telepathy::UIntList& IDs)
03808 {
03809 if (!invalidationReason().isEmpty()) {
03810 return QDBusPendingReply<>(QDBusMessage::createError(
03811 invalidationReason(),
03812 invalidationMessage()
03813 ));
03814 }
03815
03816
03817 QList<QVariant> argumentList;
03818 argumentList << QVariant::fromValue(IDs);
03819 return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
03820 }
03821
03832 inline QDBusPendingReply<Telepathy::UIntList> GetMessageTypes()
03833 {
03834 if (!invalidationReason().isEmpty()) {
03835 return QDBusPendingReply<Telepathy::UIntList>(QDBusMessage::createError(
03836 invalidationReason(),
03837 invalidationMessage()
03838 ));
03839 }
03840
03841
03842 return asyncCall(QLatin1String("GetMessageTypes"));
03843 }
03844
03868 inline QDBusPendingReply<Telepathy::PendingTextMessageList> ListPendingMessages(bool clear)
03869 {
03870 if (!invalidationReason().isEmpty()) {
03871 return QDBusPendingReply<Telepathy::PendingTextMessageList>(QDBusMessage::createError(
03872 invalidationReason(),
03873 invalidationMessage()
03874 ));
03875 }
03876
03877
03878 QList<QVariant> argumentList;
03879 argumentList << QVariant::fromValue(clear);
03880 return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
03881 }
03882
03908 inline QDBusPendingReply<> Send(uint type, const QString& text)
03909 {
03910 if (!invalidationReason().isEmpty()) {
03911 return QDBusPendingReply<>(QDBusMessage::createError(
03912 invalidationReason(),
03913 invalidationMessage()
03914 ));
03915 }
03916
03917
03918 QList<QVariant> argumentList;
03919 argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
03920 return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
03921 }
03922
03923 Q_SIGNALS:
03931 void LostMessage();
03932
03966 void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
03967
03994 void SendError(uint error, uint timestamp, uint type, const QString& text);
03995
04017 void Sent(uint timestamp, uint type, const QString& text);
04018
04019 protected:
04020 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
04021 };
04022
04030 class ChannelTypeTubesInterface : public Telepathy::Client::AbstractInterface
04031 {
04032 Q_OBJECT
04033
04034 public:
04041 static inline const char *staticInterfaceName()
04042 {
04043 return "org.freedesktop.Telepathy.Channel.Type.Tubes";
04044 }
04045
04053 ChannelTypeTubesInterface(
04054 const QString& serviceName,
04055 const QString& objectPath,
04056 QObject* parent = 0
04057 );
04058
04067 ChannelTypeTubesInterface(
04068 const QDBusConnection& connection,
04069 const QString& serviceName,
04070 const QString& objectPath,
04071 QObject* parent = 0
04072 );
04073
04080 ChannelTypeTubesInterface(Telepathy::Client::DBusProxy *proxy);
04081
04089 explicit ChannelTypeTubesInterface(const Telepathy::Client::ChannelInterface& mainInterface);
04090
04098 ChannelTypeTubesInterface(const Telepathy::Client::ChannelInterface& mainInterface, QObject* parent);
04099
04100 public Q_SLOTS:
04130 inline QDBusPendingReply<Telepathy::SupportedSocketMap> GetAvailableStreamTubeTypes()
04131 {
04132 if (!invalidationReason().isEmpty()) {
04133 return QDBusPendingReply<Telepathy::SupportedSocketMap>(QDBusMessage::createError(
04134 invalidationReason(),
04135 invalidationMessage()
04136 ));
04137 }
04138
04139
04140 return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
04141 }
04142
04151 inline QDBusPendingReply<Telepathy::UIntList> GetAvailableTubeTypes()
04152 {
04153 if (!invalidationReason().isEmpty()) {
04154 return QDBusPendingReply<Telepathy::UIntList>(QDBusMessage::createError(
04155 invalidationReason(),
04156 invalidationMessage()
04157 ));
04158 }
04159
04160
04161 return asyncCall(QLatin1String("GetAvailableTubeTypes"));
04162 }
04163
04174 inline QDBusPendingReply<Telepathy::TubeInfoList> ListTubes()
04175 {
04176 if (!invalidationReason().isEmpty()) {
04177 return QDBusPendingReply<Telepathy::TubeInfoList>(QDBusMessage::createError(
04178 invalidationReason(),
04179 invalidationMessage()
04180 ));
04181 }
04182
04183
04184 return asyncCall(QLatin1String("ListTubes"));
04185 }
04186
04209 inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
04210 {
04211 if (!invalidationReason().isEmpty()) {
04212 return QDBusPendingReply<uint>(QDBusMessage::createError(
04213 invalidationReason(),
04214 invalidationMessage()
04215 ));
04216 }
04217
04218
04219 QList<QVariant> argumentList;
04220 argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
04221 return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
04222 }
04223
04274 inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
04275 {
04276 if (!invalidationReason().isEmpty()) {
04277 return QDBusPendingReply<uint>(QDBusMessage::createError(
04278 invalidationReason(),
04279 invalidationMessage()
04280 ));
04281 }
04282
04283
04284 QList<QVariant> argumentList;
04285 argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
04286 return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
04287 }
04288
04306 inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
04307 {
04308 if (!invalidationReason().isEmpty()) {
04309 return QDBusPendingReply<QString>(QDBusMessage::createError(
04310 invalidationReason(),
04311 invalidationMessage()
04312 ));
04313 }
04314
04315
04316 QList<QVariant> argumentList;
04317 argumentList << QVariant::fromValue(ID);
04318 return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
04319 }
04320
04353 inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
04354 {
04355 if (!invalidationReason().isEmpty()) {
04356 return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04357 invalidationReason(),
04358 invalidationMessage()
04359 ));
04360 }
04361
04362
04363 QList<QVariant> argumentList;
04364 argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
04365 return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
04366 }
04367
04377 inline QDBusPendingReply<> CloseTube(uint ID)
04378 {
04379 if (!invalidationReason().isEmpty()) {
04380 return QDBusPendingReply<>(QDBusMessage::createError(
04381 invalidationReason(),
04382 invalidationMessage()
04383 ));
04384 }
04385
04386
04387 QList<QVariant> argumentList;
04388 argumentList << QVariant::fromValue(ID);
04389 return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
04390 }
04391
04406 inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
04407 {
04408 if (!invalidationReason().isEmpty()) {
04409 return QDBusPendingReply<QString>(QDBusMessage::createError(
04410 invalidationReason(),
04411 invalidationMessage()
04412 ));
04413 }
04414
04415
04416 QList<QVariant> argumentList;
04417 argumentList << QVariant::fromValue(ID);
04418 return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
04419 }
04420
04436 inline QDBusPendingReply<Telepathy::DBusTubeMemberList> GetDBusNames(uint ID)
04437 {
04438 if (!invalidationReason().isEmpty()) {
04439 return QDBusPendingReply<Telepathy::DBusTubeMemberList>(QDBusMessage::createError(
04440 invalidationReason(),
04441 invalidationMessage()
04442 ));
04443 }
04444
04445
04446 QList<QVariant> argumentList;
04447 argumentList << QVariant::fromValue(ID);
04448 return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
04449 }
04450
04471 inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
04472 {
04473 if (!invalidationReason().isEmpty()) {
04474 return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
04475 invalidationReason(),
04476 invalidationMessage()
04477 ));
04478 }
04479
04480
04481 QList<QVariant> argumentList;
04482 argumentList << QVariant::fromValue(ID);
04483 return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
04484 }
04485
04486 Q_SIGNALS:
04516 void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
04517
04531 void TubeStateChanged(uint ID, uint state);
04532
04543 void TubeClosed(uint ID);
04544
04563 void DBusNamesChanged(uint ID, const Telepathy::DBusTubeMemberList& added, const Telepathy::UIntList& removed);
04564
04579 void StreamTubeNewConnection(uint ID, uint handle);
04580
04581 protected:
04582 virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
04583 };
04584 }
04585 }