00001
00022 #ifndef _TelepathyQt_base_channel_h_HEADER_GUARD_
00023 #define _TelepathyQt_base_channel_h_HEADER_GUARD_
00024
00025 #ifndef IN_TP_QT_HEADER
00026 #error IN_TP_QT_HEADER
00027 #endif
00028
00029 #include <TelepathyQt/DBusService>
00030 #include <TelepathyQt/Global>
00031 #include <TelepathyQt/Types>
00032 #include <TelepathyQt/Callbacks>
00033 #include <TelepathyQt/Constants>
00034
00035 #include <QDBusConnection>
00036
00037 class QString;
00038
00039 namespace Tp
00040 {
00041
00042 class TP_QT_EXPORT BaseChannel : public DBusService
00043 {
00044 Q_OBJECT
00045 Q_DISABLE_COPY(BaseChannel)
00046
00047 public:
00048 static BaseChannelPtr create(BaseConnection *connection, const QString &channelType,
00049 Tp::HandleType targetHandleType = Tp::HandleTypeNone, uint targetHandle = 0) {
00050 return BaseChannelPtr(new BaseChannel(QDBusConnection::sessionBus(), connection,
00051 channelType, targetHandleType, targetHandle));
00052 }
00053
00054 virtual ~BaseChannel();
00055
00056 QVariantMap immutableProperties() const;
00057 bool registerObject(DBusError *error = NULL);
00058 virtual QString uniqueName() const;
00059
00060 Tp::BaseConnection *connection() const;
00061
00062 QString channelType() const;
00063 QList<AbstractChannelInterfacePtr> interfaces() const;
00064 AbstractChannelInterfacePtr interface(const QString &interfaceName) const;
00065 uint targetHandle() const;
00066 QString targetID() const;
00067 uint targetHandleType() const;
00068 bool requested() const;
00069 uint initiatorHandle() const;
00070 QString initiatorID() const;
00071 Tp::ChannelDetails details() const;
00072
00073 void setInitiatorHandle(uint initiatorHandle);
00074 void setInitiatorID(const QString &initiatorID);
00075 void setTargetID(const QString &targetID);
00076 void setRequested(bool requested);
00077
00078 void close();
00079
00080 bool plugInterface(const AbstractChannelInterfacePtr &interface);
00081
00082 Q_SIGNALS:
00083 void closed();
00084 protected:
00085 BaseChannel(const QDBusConnection &dbusConnection, BaseConnection *connection,
00086 const QString &channelType, uint targetHandleType, uint targetHandle);
00087 virtual bool registerObject(const QString &busName, const QString &objectPath,
00088 DBusError *error);
00089 private:
00090 class Adaptee;
00091 friend class Adaptee;
00092 struct Private;
00093 friend struct Private;
00094 Private *mPriv;
00095 };
00096
00097 class TP_QT_EXPORT AbstractChannelInterface : public AbstractDBusServiceInterface
00098 {
00099 Q_OBJECT
00100 Q_DISABLE_COPY(AbstractChannelInterface)
00101
00102 public:
00103 AbstractChannelInterface(const QString &interfaceName);
00104 virtual ~AbstractChannelInterface();
00105
00106 protected:
00107 virtual void close();
00108 virtual void setBaseChannel(BaseChannel *channel);
00109
00110 private:
00111 friend class BaseChannel;
00112
00113 struct Private;
00114 friend struct Private;
00115 Private *mPriv;
00116
00117 };
00118
00119 class TP_QT_EXPORT BaseChannelTextType : public AbstractChannelInterface
00120 {
00121 Q_OBJECT
00122 Q_DISABLE_COPY(BaseChannelTextType)
00123
00124 public:
00125 static BaseChannelTextTypePtr create(BaseChannel* channel) {
00126 return BaseChannelTextTypePtr(new BaseChannelTextType(channel));
00127 }
00128 template<typename BaseChannelTextTypeSubclass>
00129 static SharedPtr<BaseChannelTextTypeSubclass> create(BaseChannel* channel) {
00130 return SharedPtr<BaseChannelTextTypeSubclass>(
00131 new BaseChannelTextTypeSubclass(channel));
00132 }
00133
00134 typedef Callback2<QDBusObjectPath, const QVariantMap&, DBusError*> CreateChannelCallback;
00135 CreateChannelCallback createChannel;
00136
00137 typedef Callback2<bool, const QVariantMap&, DBusError*> EnsureChannelCallback;
00138 EnsureChannelCallback ensureChannel;
00139
00140 virtual ~BaseChannelTextType();
00141
00142 QVariantMap immutableProperties() const;
00143
00144 Tp::RequestableChannelClassList requestableChannelClasses;
00145
00146 typedef Callback1<void, QString> MessageAcknowledgedCallback;
00147 void setMessageAcknowledgedCallback(const MessageAcknowledgedCallback &cb);
00148
00149 Tp::MessagePartListList pendingMessages();
00150
00151
00152 void addReceivedMessage(const Tp::MessagePartList &message);
00153 private Q_SLOTS:
00154 void sent(uint timestamp, uint type, QString text);
00155 protected:
00156 BaseChannelTextType(BaseChannel* channel);
00157 void acknowledgePendingMessages(const Tp::UIntList &IDs, DBusError* error);
00158
00159 private:
00160 void createAdaptor();
00161
00162 class Adaptee;
00163 friend class Adaptee;
00164 struct Private;
00165 friend struct Private;
00166 Private *mPriv;
00167 };
00168
00169 class TP_QT_EXPORT BaseChannelMessagesInterface : public AbstractChannelInterface
00170 {
00171 Q_OBJECT
00172 Q_DISABLE_COPY(BaseChannelMessagesInterface)
00173
00174 public:
00175 static BaseChannelMessagesInterfacePtr create(BaseChannelTextType* textTypeInterface,
00176 QStringList supportedContentTypes,
00177 UIntList messageTypes,
00178 uint messagePartSupportFlags,
00179 uint deliveryReportingSupport) {
00180 return BaseChannelMessagesInterfacePtr(new BaseChannelMessagesInterface(textTypeInterface,
00181 supportedContentTypes,
00182 messageTypes,
00183 messagePartSupportFlags,
00184 deliveryReportingSupport));
00185 }
00186 template<typename BaseChannelMessagesInterfaceSubclass>
00187 static SharedPtr<BaseChannelMessagesInterfaceSubclass> create() {
00188 return SharedPtr<BaseChannelMessagesInterfaceSubclass>(
00189 new BaseChannelMessagesInterfaceSubclass());
00190 }
00191 virtual ~BaseChannelMessagesInterface();
00192
00193 QVariantMap immutableProperties() const;
00194
00195 QStringList supportedContentTypes();
00196 Tp::UIntList messageTypes();
00197 uint messagePartSupportFlags();
00198 uint deliveryReportingSupport();
00199 Tp::MessagePartListList pendingMessages();
00200
00201 void messageSent(const Tp::MessagePartList &content, uint flags, const QString &messageToken);
00202
00203 typedef Callback3<QString, const Tp::MessagePartList&, uint, DBusError*> SendMessageCallback;
00204 void setSendMessageCallback(const SendMessageCallback &cb);
00205 protected:
00206 QString sendMessage(const Tp::MessagePartList &message, uint flags, DBusError* error);
00207 private Q_SLOTS:
00208 void pendingMessagesRemoved(const Tp::UIntList &messageIDs);
00209 void messageReceived(const Tp::MessagePartList &message);
00210 private:
00211 BaseChannelMessagesInterface(BaseChannelTextType* textType,
00212 QStringList supportedContentTypes,
00213 Tp::UIntList messageTypes,
00214 uint messagePartSupportFlags,
00215 uint deliveryReportingSupport);
00216 void createAdaptor();
00217
00218 class Adaptee;
00219 friend class Adaptee;
00220 struct Private;
00221 friend struct Private;
00222 Private *mPriv;
00223 };
00224
00225 class TP_QT_EXPORT BaseChannelFileTransferType : public AbstractChannelInterface
00226 {
00227 Q_OBJECT
00228 Q_DISABLE_COPY(BaseChannelFileTransferType)
00229
00230 public:
00231 enum Direction {
00232 Incoming,
00233 Outgoing
00234 };
00235
00236 static BaseChannelFileTransferTypePtr create(const QVariantMap &request)
00237 {
00238 return BaseChannelFileTransferTypePtr(new BaseChannelFileTransferType(request));
00239 }
00240 template<typename BaseChannelFileTransferTypeSubclass>
00241 static SharedPtr<BaseChannelFileTransferTypeSubclass> create(const QVariantMap &request)
00242 {
00243 return SharedPtr<BaseChannelFileTransferTypeSubclass>(
00244 new BaseChannelFileTransferTypeSubclass(request));
00245 }
00246
00247 virtual ~BaseChannelFileTransferType();
00248
00249 QVariantMap immutableProperties() const;
00250 Direction direction() const;
00251
00252 QString contentType() const;
00253 QString filename() const;
00254 qulonglong size() const;
00255 uint contentHashType() const;
00256 QString contentHash() const;
00257 QString description() const;
00258 QDateTime date() const;
00259 virtual Tp::SupportedSocketMap availableSocketTypes() const;
00260
00261 uint state() const;
00262 void setState(uint state, uint reason);
00263
00264 qulonglong transferredBytes() const;
00265 void setTransferredBytes(qulonglong count);
00266 qulonglong initialOffset() const;
00267
00268 QString uri() const;
00269
00270 QString fileCollection() const;
00271 void setFileCollection(const QString &fileCollection);
00272
00273 bool remoteAcceptFile(QIODevice *output, qulonglong offset);
00274 bool remoteProvideFile(QIODevice *input, qulonglong deviceOffset = 0);
00275
00276 Q_SIGNALS:
00277 void stateChanged(uint state, uint reason);
00278 void uriDefined(const QString &uri);
00279
00280 protected:
00281 BaseChannelFileTransferType(const QVariantMap &request);
00282
00283 virtual bool createSocket(uint addressType, uint accessControl, const QDBusVariant &accessControlParam, DBusError *error);
00284 virtual QDBusVariant socketAddress() const;
00285
00286 void setClientSocket(QIODevice *socket);
00287
00288 void close();
00289
00290 private Q_SLOTS:
00291 TP_QT_NO_EXPORT void onSocketConnection();
00292 TP_QT_NO_EXPORT void doTransfer();
00293 TP_QT_NO_EXPORT void onBytesWritten(qint64 count);
00294
00295 private:
00296 TP_QT_NO_EXPORT void setUri(const QString &uri);
00297 TP_QT_NO_EXPORT void tryToOpenAndTransfer();
00298
00299 void createAdaptor();
00300
00301 class Adaptee;
00302 friend class Adaptee;
00303 struct Private;
00304 friend struct Private;
00305 Private *mPriv;
00306 };
00307
00308 class TP_QT_EXPORT BaseChannelRoomListType : public AbstractChannelInterface
00309 {
00310 Q_OBJECT
00311 Q_DISABLE_COPY(BaseChannelRoomListType)
00312
00313 public:
00314 static BaseChannelRoomListTypePtr create(const QString &server = QString())
00315 {
00316 return BaseChannelRoomListTypePtr(new BaseChannelRoomListType(server));
00317 }
00318 template<typename BaseChannelRoomListTypeSubclass>
00319 static SharedPtr<BaseChannelRoomListTypeSubclass> create(const QString &server = QString())
00320 {
00321 return SharedPtr<BaseChannelRoomListTypeSubclass>(
00322 new BaseChannelRoomListTypeSubclass(server));
00323 }
00324
00325 virtual ~BaseChannelRoomListType();
00326
00327 QVariantMap immutableProperties() const;
00328
00329 QString server() const;
00330
00331 bool getListingRooms();
00332 void setListingRooms(bool listing);
00333
00334 typedef Callback1<void, DBusError*> ListRoomsCallback;
00335 void setListRoomsCallback(const ListRoomsCallback &cb);
00336 void listRooms(DBusError *error);
00337
00338 typedef Callback1<void, DBusError*> StopListingCallback;
00339 void setStopListingCallback(const StopListingCallback &cb);
00340 void stopListing(DBusError *error);
00341
00342 void gotRooms(const Tp::RoomInfoList &rooms);
00343
00344 protected:
00345 BaseChannelRoomListType(const QString &server);
00346
00347 private:
00348 void createAdaptor();
00349
00350 class Adaptee;
00351 friend class Adaptee;
00352 struct Private;
00353 friend struct Private;
00354 Private *mPriv;
00355 };
00356
00357 class TP_QT_EXPORT BaseChannelServerAuthenticationType : public AbstractChannelInterface
00358 {
00359 Q_OBJECT
00360 Q_DISABLE_COPY(BaseChannelServerAuthenticationType)
00361
00362 public:
00363 static BaseChannelServerAuthenticationTypePtr create(const QString &authenticationMethod) {
00364 return BaseChannelServerAuthenticationTypePtr(new BaseChannelServerAuthenticationType(authenticationMethod));
00365 }
00366 template<typename BaseChannelServerAuthenticationTypeSubclass>
00367 static SharedPtr<BaseChannelServerAuthenticationTypeSubclass> create(const QString &authenticationMethod) {
00368 return SharedPtr<BaseChannelServerAuthenticationTypeSubclass>(
00369 new BaseChannelServerAuthenticationTypeSubclass(authenticationMethod));
00370 }
00371 virtual ~BaseChannelServerAuthenticationType();
00372
00373 QVariantMap immutableProperties() const;
00374 private Q_SLOTS:
00375 private:
00376 BaseChannelServerAuthenticationType(const QString &authenticationMethod);
00377 void createAdaptor();
00378
00379 class Adaptee;
00380 friend class Adaptee;
00381 struct Private;
00382 friend struct Private;
00383 Private *mPriv;
00384 };
00385
00386 class TP_QT_EXPORT BaseChannelCaptchaAuthenticationInterface : public AbstractChannelInterface
00387 {
00388 Q_OBJECT
00389 Q_DISABLE_COPY(BaseChannelCaptchaAuthenticationInterface)
00390
00391 public:
00392 static BaseChannelCaptchaAuthenticationInterfacePtr create(bool canRetryCaptcha) {
00393 return BaseChannelCaptchaAuthenticationInterfacePtr(new BaseChannelCaptchaAuthenticationInterface(canRetryCaptcha));
00394 }
00395 template<typename BaseChannelCaptchaAuthenticationInterfaceSubclass>
00396 static SharedPtr<BaseChannelCaptchaAuthenticationInterfaceSubclass> create(bool canRetryCaptcha) {
00397 return SharedPtr<BaseChannelCaptchaAuthenticationInterfaceSubclass>(
00398 new BaseChannelCaptchaAuthenticationInterfaceSubclass(canRetryCaptcha));
00399 }
00400 virtual ~BaseChannelCaptchaAuthenticationInterface();
00401
00402 QVariantMap immutableProperties() const;
00403
00404 typedef Callback4<void, Tp::CaptchaInfoList&, uint&, QString&, DBusError*> GetCaptchasCallback;
00405 void setGetCaptchasCallback(const GetCaptchasCallback &cb);
00406
00407 typedef Callback3<QByteArray, uint, const QString&, DBusError*> GetCaptchaDataCallback;
00408 void setGetCaptchaDataCallback(const GetCaptchaDataCallback &cb);
00409
00410 typedef Callback2<void, const Tp::CaptchaAnswers&, DBusError*> AnswerCaptchasCallback;
00411 void setAnswerCaptchasCallback(const AnswerCaptchasCallback &cb);
00412
00413 typedef Callback3<void, uint, const QString&, DBusError*> CancelCaptchaCallback;
00414 void setCancelCaptchaCallback(const CancelCaptchaCallback &cb);
00415
00416 void setCaptchaStatus(uint status);
00417 void setCaptchaError(const QString &busName);
00418 void setCaptchaErrorDetails(const QVariantMap &error);
00419 private Q_SLOTS:
00420 private:
00421 BaseChannelCaptchaAuthenticationInterface(bool canRetryCaptcha);
00422 void createAdaptor();
00423
00424 class Adaptee;
00425 friend class Adaptee;
00426 struct Private;
00427 friend struct Private;
00428 Private *mPriv;
00429 };
00430
00431 class TP_QT_EXPORT BaseChannelSASLAuthenticationInterface : public AbstractChannelInterface
00432 {
00433 Q_OBJECT
00434 Q_DISABLE_COPY(BaseChannelSASLAuthenticationInterface)
00435
00436 public:
00437 static BaseChannelSASLAuthenticationInterfacePtr create(const QStringList &availableMechanisms,
00438 bool hasInitialData,
00439 bool canTryAgain,
00440 const QString &authorizationIdentity,
00441 const QString &defaultUsername,
00442 const QString &defaultRealm,
00443 bool maySaveResponse)
00444 {
00445 return BaseChannelSASLAuthenticationInterfacePtr(new BaseChannelSASLAuthenticationInterface(availableMechanisms,
00446 hasInitialData,
00447 canTryAgain,
00448 authorizationIdentity,
00449 defaultUsername,
00450 defaultRealm,
00451 maySaveResponse));
00452 }
00453 template<typename BaseChannelSASLAuthenticationInterfaceSubclass>
00454 static SharedPtr<BaseChannelSASLAuthenticationInterfaceSubclass> create(const QStringList &availableMechanisms,
00455 bool hasInitialData,
00456 bool canTryAgain,
00457 const QString &authorizationIdentity,
00458 const QString &defaultUsername,
00459 const QString &defaultRealm,
00460 bool maySaveResponse)
00461 {
00462 return SharedPtr<BaseChannelSASLAuthenticationInterfaceSubclass>(
00463 new BaseChannelSASLAuthenticationInterfaceSubclass(availableMechanisms,
00464 hasInitialData,
00465 canTryAgain,
00466 authorizationIdentity,
00467 defaultUsername,
00468 defaultRealm,
00469 maySaveResponse));
00470 }
00471
00472 virtual ~BaseChannelSASLAuthenticationInterface();
00473
00474 QVariantMap immutableProperties() const;
00475
00476 QStringList availableMechanisms() const;
00477 bool hasInitialData() const;
00478 bool canTryAgain() const;
00479 QString authorizationIdentity() const;
00480 QString defaultUsername() const;
00481 QString defaultRealm() const;
00482 bool maySaveResponse() const;
00483
00484 uint saslStatus() const;
00485 void setSaslStatus(uint status, const QString &reason, const QVariantMap &details);
00486
00487 QString saslError() const;
00488 void setSaslError(const QString &saslError);
00489
00490 QVariantMap saslErrorDetails() const;
00491 void setSaslErrorDetails(const QVariantMap &saslErrorDetails);
00492
00493 typedef Callback2<void, const QString &, DBusError*> StartMechanismCallback;
00494 void setStartMechanismCallback(const StartMechanismCallback &cb);
00495 void startMechanism(const QString &mechanism, DBusError *error);
00496
00497 typedef Callback3<void, const QString &, const QByteArray &, DBusError*> StartMechanismWithDataCallback;
00498 void setStartMechanismWithDataCallback(const StartMechanismWithDataCallback &cb);
00499 void startMechanismWithData(const QString &mechanism, const QByteArray &initialData, DBusError *error);
00500
00501 typedef Callback2<void, const QByteArray &, DBusError*> RespondCallback;
00502 void setRespondCallback(const RespondCallback &cb);
00503 void respond(const QByteArray &responseData, DBusError *error);
00504
00505 typedef Callback1<void, DBusError*> AcceptSASLCallback;
00506 void setAcceptSaslCallback(const AcceptSASLCallback &cb);
00507 void acceptSasl(DBusError *error);
00508
00509 typedef Callback3<void, uint, const QString &, DBusError*> AbortSASLCallback;
00510 void setAbortSaslCallback(const AbortSASLCallback &cb);
00511 void abortSasl(uint reason, const QString &debugMessage, DBusError *error);
00512
00513 void newChallenge(const QByteArray &challengeData);
00514
00515 protected:
00516 BaseChannelSASLAuthenticationInterface(const QStringList &availableMechanisms,
00517 bool hasInitialData,
00518 bool canTryAgain,
00519 const QString &authorizationIdentity,
00520 const QString &defaultUsername,
00521 const QString &defaultRealm,
00522 bool maySaveResponse);
00523
00524 private:
00525 void createAdaptor();
00526
00527 class Adaptee;
00528 friend class Adaptee;
00529 struct Private;
00530 friend struct Private;
00531 Private *mPriv;
00532 };
00533
00534 class TP_QT_EXPORT BaseChannelSecurableInterface : public AbstractChannelInterface
00535 {
00536 Q_OBJECT
00537 Q_DISABLE_COPY(BaseChannelSecurableInterface)
00538
00539 public:
00540 static BaseChannelSecurableInterfacePtr create()
00541 {
00542 return BaseChannelSecurableInterfacePtr(new BaseChannelSecurableInterface());
00543 }
00544 template<typename BaseChannelSecurableInterfaceSubclass>
00545 static SharedPtr<BaseChannelSecurableInterfaceSubclass> create()
00546 {
00547 return SharedPtr<BaseChannelSecurableInterfaceSubclass>(
00548 new BaseChannelSecurableInterfaceSubclass());
00549 }
00550
00551 virtual ~BaseChannelSecurableInterface();
00552
00553 QVariantMap immutableProperties() const;
00554
00555 bool encrypted() const;
00556 void setEncrypted(bool encrypted);
00557
00558 bool verified() const;
00559 void setVerified(bool verified);
00560
00561 protected:
00562 BaseChannelSecurableInterface();
00563
00564 private:
00565 void createAdaptor();
00566
00567 class Adaptee;
00568 friend class Adaptee;
00569 struct Private;
00570 friend struct Private;
00571 Private *mPriv;
00572 };
00573
00574 class TP_QT_EXPORT BaseChannelChatStateInterface : public AbstractChannelInterface
00575 {
00576 Q_OBJECT
00577 Q_DISABLE_COPY(BaseChannelChatStateInterface)
00578
00579 public:
00580 static BaseChannelChatStateInterfacePtr create()
00581 {
00582 return BaseChannelChatStateInterfacePtr(new BaseChannelChatStateInterface());
00583 }
00584 template<typename BaseChannelChatStateInterfaceSubclass>
00585 static SharedPtr<BaseChannelChatStateInterfaceSubclass> create()
00586 {
00587 return SharedPtr<BaseChannelChatStateInterfaceSubclass>(
00588 new BaseChannelChatStateInterfaceSubclass());
00589 }
00590
00591 virtual ~BaseChannelChatStateInterface();
00592
00593 QVariantMap immutableProperties() const;
00594
00595 Tp::ChatStateMap chatStates() const;
00596 void setChatStates(const Tp::ChatStateMap &chatStates);
00597
00598 typedef Callback2<void, uint, DBusError*> SetChatStateCallback;
00599 void setSetChatStateCallback(const SetChatStateCallback &cb);
00600 void setChatState(uint state, DBusError *error);
00601
00602 void chatStateChanged(uint contact, uint state);
00603
00604 protected:
00605 BaseChannelChatStateInterface();
00606
00607 private:
00608 void createAdaptor();
00609
00610 class Adaptee;
00611 friend class Adaptee;
00612 struct Private;
00613 friend struct Private;
00614 Private *mPriv;
00615 };
00616
00617 class TP_QT_EXPORT BaseChannelGroupInterface : public AbstractChannelInterface
00618 {
00619 Q_OBJECT
00620 Q_DISABLE_COPY(BaseChannelGroupInterface)
00621
00622 public:
00623 static BaseChannelGroupInterfacePtr create()
00624 {
00625 return BaseChannelGroupInterfacePtr(new BaseChannelGroupInterface());
00626 }
00627 template<typename BaseChannelGroupInterfaceSubclass>
00628 static SharedPtr<BaseChannelGroupInterfaceSubclass> create()
00629 {
00630 return SharedPtr<BaseChannelGroupInterfaceSubclass>(
00631 new BaseChannelGroupInterfaceSubclass());
00632 }
00633
00634 virtual ~BaseChannelGroupInterface();
00635
00636 QVariantMap immutableProperties() const;
00637
00638 Tp::ChannelGroupFlags groupFlags() const;
00639 void setGroupFlags(const Tp::ChannelGroupFlags &flags);
00640
00641 Tp::UIntList members() const;
00642 void setMembers(const Tp::UIntList &members, const QVariantMap &details);
00643 void setMembers(const Tp::UIntList &members, const Tp::LocalPendingInfoList &localPending, const Tp::UIntList &remotePending, const QVariantMap &details);
00644
00645 Tp::HandleOwnerMap handleOwners() const;
00646 void setHandleOwners(const Tp::HandleOwnerMap &handleOwners);
00647
00648 Tp::LocalPendingInfoList localPendingMembers() const;
00649 void setLocalPendingMembers(const Tp::LocalPendingInfoList &localPendingMembers);
00650
00651 Tp::UIntList remotePendingMembers() const;
00652 void setRemotePendingMembers(const Tp::UIntList &remotePendingMembers);
00653
00654 uint selfHandle() const;
00655 void setSelfHandle(uint selfHandle);
00656
00657 Tp::HandleIdentifierMap memberIdentifiers() const;
00658
00659 typedef Callback3<void, const Tp::UIntList &, const QString &, DBusError*> AddMembersCallback;
00660 void setAddMembersCallback(const AddMembersCallback &cb);
00661 void addMembers(const Tp::UIntList &contacts, const QString &message, DBusError *error);
00662
00663 typedef Callback4<void, const Tp::UIntList &, const QString &, uint, DBusError*> RemoveMembersCallback;
00664 void setRemoveMembersCallback(const RemoveMembersCallback &cb);
00665 void removeMembers(const Tp::UIntList &contacts, const QString &message, uint reason, DBusError *error);
00666
00667 protected:
00668 BaseChannelGroupInterface();
00669 void setBaseChannel(BaseChannel *channel);
00670
00671 private:
00672 void createAdaptor();
00673
00674 class Adaptee;
00675 friend class Adaptee;
00676 struct Private;
00677 friend struct Private;
00678 Private *mPriv;
00679 };
00680
00681 class TP_QT_EXPORT BaseChannelRoomInterface : public AbstractChannelInterface
00682 {
00683 Q_OBJECT
00684 Q_DISABLE_COPY(BaseChannelRoomInterface)
00685
00686 public:
00687 static BaseChannelRoomInterfacePtr create(const QString &roomName,
00688 const QString &server,
00689 const QString &creator,
00690 uint creatorHandle,
00691 const QDateTime &creationTimestamp)
00692 {
00693 return BaseChannelRoomInterfacePtr(new BaseChannelRoomInterface(roomName,
00694 server,
00695 creator,
00696 creatorHandle,
00697 creationTimestamp));
00698 }
00699 template<typename BaseChannelRoomInterfaceSubclass>
00700 static SharedPtr<BaseChannelRoomInterfaceSubclass> create(const QString &roomName,
00701 const QString &server,
00702 const QString &creator,
00703 uint creatorHandle,
00704 const QDateTime &creationTimestamp)
00705 {
00706 return SharedPtr<BaseChannelRoomInterfaceSubclass>(
00707 new BaseChannelRoomInterfaceSubclass(roomName,
00708 server,
00709 creator,
00710 creatorHandle,
00711 creationTimestamp));
00712 }
00713
00714 virtual ~BaseChannelRoomInterface();
00715
00716 QVariantMap immutableProperties() const;
00717
00718 QString roomName() const;
00719 QString server() const;
00720 QString creator() const;
00721 uint creatorHandle() const;
00722 QDateTime creationTimestamp() const;
00723
00724 protected:
00725 BaseChannelRoomInterface(const QString &roomName,
00726 const QString &server,
00727 const QString &creator,
00728 uint creatorHandle,
00729 const QDateTime &creationTimestamp);
00730
00731 private:
00732 void createAdaptor();
00733
00734 class Adaptee;
00735 friend class Adaptee;
00736 struct Private;
00737 friend struct Private;
00738 Private *mPriv;
00739 };
00740
00741 class TP_QT_EXPORT BaseChannelRoomConfigInterface : public AbstractChannelInterface
00742 {
00743 Q_OBJECT
00744 Q_DISABLE_COPY(BaseChannelRoomConfigInterface)
00745
00746 public:
00747 static BaseChannelRoomConfigInterfacePtr create()
00748 {
00749 return BaseChannelRoomConfigInterfacePtr(new BaseChannelRoomConfigInterface());
00750 }
00751 template<typename BaseChannelRoomConfigInterfaceSubclass>
00752 static SharedPtr<BaseChannelRoomConfigInterfaceSubclass> create()
00753 {
00754 return SharedPtr<BaseChannelRoomConfigInterfaceSubclass>(
00755 new BaseChannelRoomConfigInterfaceSubclass());
00756 }
00757
00758 virtual ~BaseChannelRoomConfigInterface();
00759
00760 QVariantMap immutableProperties() const;
00761
00762 bool anonymous() const;
00763 void setAnonymous(bool anonymous);
00764
00765 bool inviteOnly() const;
00766 void setInviteOnly(bool inviteOnly);
00767
00768 uint limit() const;
00769 void setLimit(uint limit);
00770
00771 bool moderated() const;
00772 void setModerated(bool moderated);
00773
00774 QString title() const;
00775 void setTitle(const QString &title);
00776
00777 QString description() const;
00778 void setDescription(const QString &description);
00779
00780 bool persistent() const;
00781 void setPersistent(bool persistent);
00782
00783 bool isPrivate() const;
00784 void setPrivate(bool newPrivate);
00785
00786 bool passwordProtected() const;
00787 void setPasswordProtected(bool passwordProtected);
00788
00789 QString password() const;
00790 void setPassword(const QString &password);
00791
00792 QString passwordHint() const;
00793 void setPasswordHint(const QString &passwordHint);
00794
00795 bool canUpdateConfiguration() const;
00796 void setCanUpdateConfiguration(bool canUpdateConfiguration);
00797
00798 QStringList mutableProperties() const;
00799 void setMutableProperties(const QStringList &mutableProperties);
00800
00801 bool configurationRetrieved() const;
00802 void setConfigurationRetrieved(bool configurationRetrieved);
00803
00804 typedef Callback2<void, const QVariantMap &, DBusError*> UpdateConfigurationCallback;
00805 void setUpdateConfigurationCallback(const UpdateConfigurationCallback &cb);
00806 void updateConfiguration(const QVariantMap &properties, DBusError *error);
00807
00808 protected:
00809 BaseChannelRoomConfigInterface();
00810
00811 private:
00812 void createAdaptor();
00813
00814 class Adaptee;
00815 friend class Adaptee;
00816 struct Private;
00817 friend struct Private;
00818 Private *mPriv;
00819 };
00820
00821 class TP_QT_EXPORT BaseChannelCallType : public AbstractChannelInterface
00822 {
00823 Q_OBJECT
00824 Q_DISABLE_COPY(BaseChannelCallType)
00825
00826 public:
00827 static BaseChannelCallTypePtr create(BaseChannel* channel, bool hardwareStreaming,
00828 uint initialTransport,
00829 bool initialAudio,
00830 bool initialVideo,
00831 QString initialAudioName,
00832 QString initialVideoName,
00833 bool mutableContents = false) {
00834 return BaseChannelCallTypePtr(new BaseChannelCallType(channel,
00835 hardwareStreaming,
00836 initialTransport,
00837 initialAudio,
00838 initialVideo,
00839 initialAudioName,
00840 initialVideoName,
00841 mutableContents));
00842 }
00843 template<typename BaseChannelCallTypeSubclass>
00844 static SharedPtr<BaseChannelCallTypeSubclass> create(BaseChannel* channel, bool hardwareStreaming,
00845 uint initialTransport,
00846 bool initialAudio,
00847 bool initialVideo,
00848 QString initialAudioName,
00849 QString initialVideoName,
00850 bool mutableContents = false) {
00851 return SharedPtr<BaseChannelCallTypeSubclass>(
00852 new BaseChannelCallTypeSubclass(channel,
00853 hardwareStreaming,
00854 initialTransport,
00855 initialAudio,
00856 initialVideo,
00857 initialAudioName,
00858 initialVideoName,
00859 mutableContents));
00860 }
00861
00862 typedef Callback2<QDBusObjectPath, const QVariantMap&, DBusError*> CreateChannelCallback;
00863 CreateChannelCallback createChannel;
00864
00865 typedef Callback2<bool, const QVariantMap&, DBusError*> EnsureChannelCallback;
00866 EnsureChannelCallback ensureChannel;
00867
00868 virtual ~BaseChannelCallType();
00869
00870 QVariantMap immutableProperties() const;
00871
00872 Tp::ObjectPathList contents();
00873 QVariantMap callStateDetails();
00874 uint callState();
00875 uint callFlags();
00876 Tp::CallStateReason callStateReason();
00877 bool hardwareStreaming();
00878 Tp::CallMemberMap callMembers();
00879 Tp::HandleIdentifierMap memberIdentifiers();
00880 uint initialTransport();
00881 bool initialAudio();
00882 bool initialVideo();
00883 QString initialAudioName();
00884 QString initialVideoName();
00885 bool mutableContents();
00886
00887 typedef Callback1<void, DBusError*> AcceptCallback;
00888 void setAcceptCallback(const AcceptCallback &cb);
00889
00890 typedef Callback4<void, uint, const QString &, const QString &, DBusError*> HangupCallback;
00891 void setHangupCallback(const HangupCallback &cb);
00892
00893 typedef Callback1<void, DBusError*> SetRingingCallback;
00894 void setSetRingingCallback(const SetRingingCallback &cb);
00895
00896 typedef Callback1<void, DBusError*> SetQueuedCallback;
00897 void setSetQueuedCallback(const SetQueuedCallback &cb);
00898
00899 typedef Callback4<QDBusObjectPath, const QString&, const Tp::MediaStreamType&, const Tp::MediaStreamDirection&, DBusError*> AddContentCallback;
00900 void setAddContentCallback(const AddContentCallback &cb);
00901
00902 void setCallState(const Tp::CallState &state, uint flags, const Tp::CallStateReason &stateReason, const QVariantMap &callStateDetails);
00903 void setMembersFlags(const Tp::CallMemberMap &flagsChanged, const Tp::HandleIdentifierMap &identifiers, const Tp::UIntList &removed, const Tp::CallStateReason &reason);
00904 BaseCallContentPtr addContent(const QString &name, const Tp::MediaStreamType &type, const Tp::MediaStreamDirection &direction);
00905 void addContent(BaseCallContentPtr content);
00906
00907 Tp::RequestableChannelClassList requestableChannelClasses;
00908
00909 protected:
00910 BaseChannelCallType(BaseChannel* channel,
00911 bool hardwareStreaming,
00912 uint initialTransport,
00913 bool initialAudio,
00914 bool initialVideo,
00915 QString initialAudioName,
00916 QString initialVideoName,
00917 bool mutableContents = false);
00918
00919 private:
00920 void createAdaptor();
00921
00922 class Adaptee;
00923 friend class Adaptee;
00924 struct Private;
00925 friend struct Private;
00926 Private *mPriv;
00927 };
00928
00929 class TP_QT_EXPORT BaseChannelHoldInterface : public AbstractChannelInterface
00930 {
00931 Q_OBJECT
00932 Q_DISABLE_COPY(BaseChannelHoldInterface)
00933
00934 public:
00935 static BaseChannelHoldInterfacePtr create() {
00936 return BaseChannelHoldInterfacePtr(new BaseChannelHoldInterface());
00937 }
00938 template<typename BaseChannelHoldInterfaceSubclass>
00939 static SharedPtr<BaseChannelHoldInterfaceSubclass> create() {
00940 return SharedPtr<BaseChannelHoldInterfaceSubclass>(
00941 new BaseChannelHoldInterfaceSubclass());
00942 }
00943 virtual ~BaseChannelHoldInterface();
00944
00945 QVariantMap immutableProperties() const;
00946
00947 Tp::LocalHoldState getHoldState() const;
00948 Tp::LocalHoldStateReason getHoldReason() const;
00949 void setHoldState(const Tp::LocalHoldState &state, const Tp::LocalHoldStateReason &reason);
00950
00951 typedef Callback3<void, const Tp::LocalHoldState&, const Tp::LocalHoldStateReason &, DBusError*> SetHoldStateCallback;
00952 void setSetHoldStateCallback(const SetHoldStateCallback &cb);
00953 Q_SIGNALS:
00954 void holdStateChanged(const Tp::LocalHoldState &state, const Tp::LocalHoldStateReason &reason);
00955 private:
00956 BaseChannelHoldInterface();
00957 void createAdaptor();
00958
00959 class Adaptee;
00960 friend class Adaptee;
00961 struct Private;
00962 friend struct Private;
00963 Private *mPriv;
00964 };
00965
00966 class TP_QT_EXPORT BaseChannelMergeableConferenceInterface : public AbstractChannelInterface
00967 {
00968 Q_OBJECT
00969 Q_DISABLE_COPY(BaseChannelMergeableConferenceInterface)
00970
00971 public:
00972 static BaseChannelMergeableConferenceInterfacePtr create() {
00973 return BaseChannelMergeableConferenceInterfacePtr(new BaseChannelMergeableConferenceInterface());
00974 }
00975 template<typename BaseChannelMergeableConferenceInterfaceSubclass>
00976 static SharedPtr<BaseChannelMergeableConferenceInterfaceSubclass> create() {
00977 return SharedPtr<BaseChannelMergeableConferenceInterfaceSubclass>(
00978 new BaseChannelMergeableConferenceInterfaceSubclass());
00979 }
00980 virtual ~BaseChannelMergeableConferenceInterface();
00981
00982 QVariantMap immutableProperties() const;
00983
00984 void merge(const QDBusObjectPath &channel);
00985
00986 typedef Callback2<void, const QDBusObjectPath&, DBusError*> MergeCallback;
00987 void setMergeCallback(const MergeCallback &cb);
00988 private:
00989 BaseChannelMergeableConferenceInterface();
00990 void createAdaptor();
00991
00992 class Adaptee;
00993 friend class Adaptee;
00994 struct Private;
00995 friend struct Private;
00996 Private *mPriv;
00997 };
00998
00999 class TP_QT_EXPORT BaseChannelSplittableInterface : public AbstractChannelInterface
01000 {
01001 Q_OBJECT
01002 Q_DISABLE_COPY(BaseChannelSplittableInterface)
01003
01004 public:
01005 static BaseChannelSplittableInterfacePtr create() {
01006 return BaseChannelSplittableInterfacePtr(new BaseChannelSplittableInterface());
01007 }
01008 template<typename BaseChannelSplittableInterfaceSubclass>
01009 static SharedPtr<BaseChannelSplittableInterfaceSubclass> create() {
01010 return SharedPtr<BaseChannelSplittableInterfaceSubclass>(
01011 new BaseChannelSplittableInterfaceSubclass());
01012 }
01013 virtual ~BaseChannelSplittableInterface();
01014
01015 QVariantMap immutableProperties() const;
01016
01017 void split();
01018
01019 typedef Callback1<void, DBusError*> SplitCallback;
01020 void setSplitCallback(const SplitCallback &cb);
01021 private:
01022 BaseChannelSplittableInterface();
01023 void createAdaptor();
01024
01025 class Adaptee;
01026 friend class Adaptee;
01027 struct Private;
01028 friend struct Private;
01029 Private *mPriv;
01030 };
01031
01032 class TP_QT_EXPORT BaseChannelConferenceInterface : public AbstractChannelInterface
01033 {
01034 Q_OBJECT
01035 Q_DISABLE_COPY(BaseChannelConferenceInterface)
01036
01037 public:
01038 static BaseChannelConferenceInterfacePtr create(Tp::ObjectPathList initialChannels = Tp::ObjectPathList(),
01039 Tp::UIntList initialInviteeHandles = Tp::UIntList(),
01040 QStringList initialInviteeIDs = QStringList(),
01041 QString invitationMessage = QString(),
01042 ChannelOriginatorMap originalChannels = ChannelOriginatorMap()) {
01043 return BaseChannelConferenceInterfacePtr(new BaseChannelConferenceInterface(initialChannels, initialInviteeHandles, initialInviteeIDs, invitationMessage, originalChannels));
01044 }
01045 template<typename BaseChannelConferenceInterfaceSubclass>
01046 static SharedPtr<BaseChannelConferenceInterfaceSubclass> create(Tp::ObjectPathList initialChannels = Tp::ObjectPathList(),
01047 Tp::UIntList initialInviteeHandles = Tp::UIntList(),
01048 QStringList initialInviteeIDs = QStringList(),
01049 QString invitationMessage = QString(),
01050 ChannelOriginatorMap originalChannels = ChannelOriginatorMap()) {
01051 return SharedPtr<BaseChannelConferenceInterfaceSubclass>(
01052 new BaseChannelConferenceInterfaceSubclass(initialChannels, initialInviteeHandles, initialInviteeIDs, invitationMessage, originalChannels));
01053 }
01054 virtual ~BaseChannelConferenceInterface();
01055
01056 QVariantMap immutableProperties() const;
01057 Tp::ObjectPathList channels() const;
01058 Tp::ObjectPathList initialChannels() const;
01059 Tp::UIntList initialInviteeHandles() const;
01060 QStringList initialInviteeIDs() const;
01061 QString invitationMessage() const;
01062 ChannelOriginatorMap originalChannels() const;
01063
01064 void mergeChannel(const QDBusObjectPath &channel, uint channelHandle, const QVariantMap &properties);
01065 void removeChannel(const QDBusObjectPath &channel, const QVariantMap &details);
01066
01067 private:
01068 BaseChannelConferenceInterface(Tp::ObjectPathList initialChannels, Tp::UIntList initialInviteeHandles, QStringList initialInviteeIDs, QString invitationMessage, ChannelOriginatorMap originalChannels);
01069 void createAdaptor();
01070
01071 class Adaptee;
01072 friend class Adaptee;
01073 struct Private;
01074 friend struct Private;
01075 Private *mPriv;
01076 };
01077
01078 class TP_QT_EXPORT BaseChannelSMSInterface : public AbstractChannelInterface
01079 {
01080 Q_OBJECT
01081 Q_DISABLE_COPY(BaseChannelSMSInterface)
01082
01083 public:
01084 static BaseChannelSMSInterfacePtr create(bool flash, bool smsChannel) {
01085 return BaseChannelSMSInterfacePtr(new BaseChannelSMSInterface(flash, smsChannel));
01086 }
01087 template<typename BaseChannelSMSInterfaceSubclass>
01088 static SharedPtr<BaseChannelSMSInterfaceSubclass> create(bool flash, bool smsChannel) {
01089 return SharedPtr<BaseChannelSMSInterfaceSubclass>(
01090 new BaseChannelSMSInterfaceSubclass(flash, smsChannel));
01091 }
01092 virtual ~BaseChannelSMSInterface();
01093
01094 QVariantMap immutableProperties() const;
01095
01096 typedef Callback2<void, const Tp::MessagePartList &, DBusError*> GetSMSLengthCallback;
01097 void setGetSMSLengthCallback(const GetSMSLengthCallback &cb);
01098
01099 bool flash() const;
01100 bool smsChannel() const;
01101
01102 Q_SIGNALS:
01103 void smsChannelChanged(bool smsChannel);
01104
01105 private:
01106 BaseChannelSMSInterface(bool flash, bool smsChannel);
01107 void createAdaptor();
01108
01109 class Adaptee;
01110 friend class Adaptee;
01111 struct Private;
01112 friend struct Private;
01113 Private *mPriv;
01114 };
01115
01116 }
01117 #endif