// SPDX-FileCopyrightText: 2016 Kitsune Ral // SPDX-FileCopyrightText: 2017 Roman Plášil // SPDX-FileCopyrightText: 2019 Alexey Andreyev // SPDX-License-Identifier: LGPL-2.1-or-later #pragma once #include "ssosession.h" #include "joinstate.h" #include "qt_connection_util.h" #include "quotient_common.h" #include "csapi/login.h" #include "csapi/create_room.h" #include "events/accountdataevents.h" #include #include #include #include #include namespace QtOlm { class Account; } Q_DECLARE_METATYPE(Quotient::GetLoginFlowsJob::LoginFlow) namespace Quotient { class Room; class User; class ConnectionData; class RoomEvent; class SyncJob; class SyncData; class RoomMessagesJob; class PostReceiptJob; class ForgetRoomJob; class MediaThumbnailJob; class JoinRoomJob; class UploadContentJob; class GetContentJob; class DownloadFileJob; class SendToDeviceJob; class SendMessageJob; class LeaveRoomJob; using LoginFlow = GetLoginFlowsJob::LoginFlow; /// Predefined login flows struct LoginFlows { static inline const LoginFlow Password { "m.login.password" }; static inline const LoginFlow SSO { "m.login.sso" }; static inline const LoginFlow Token { "m.login.token" }; }; // To simplify comparisons of LoginFlows inline bool operator==(const LoginFlow& lhs, const LoginFlow& rhs) { return lhs.type == rhs.type; } inline bool operator!=(const LoginFlow& lhs, const LoginFlow& rhs) { return !(lhs == rhs); } class Connection; using room_factory_t = std::function; using user_factory_t = std::function; /** The default factory to create room objects * * Just a wrapper around operator new. * \sa Connection::setRoomFactory, Connection::setRoomType */ template static inline room_factory_t defaultRoomFactory() { return [](Connection* c, const QString& id, JoinState js) { return new T(c, id, js); }; } /** The default factory to create user objects * * Just a wrapper around operator new. * \sa Connection::setUserFactory, Connection::setUserType */ template static inline user_factory_t defaultUserFactory() { return [](Connection* c, const QString& id) { return new T(id, c); }; } // Room ids, rather than room pointers, are used in the direct chat // map types because the library keeps Invite rooms separate from // rooms in Join and Leave state; and direct chats in account data // are stored with no regard to their state. using DirectChatsMap = QMultiHash; using DirectChatUsersMap = QMultiHash; using IgnoredUsersList = IgnoredUsersEvent::content_type; class Connection : public QObject { Q_OBJECT Q_PROPERTY(User* localUser READ user NOTIFY stateChanged) Q_PROPERTY(QString localUserId READ userId NOTIFY stateChanged) Q_PROPERTY(QString domain READ domain NOTIFY stateChanged STORED false) Q_PROPERTY(QString deviceId READ deviceId NOTIFY stateChanged) Q_PROPERTY(QByteArray accessToken READ accessToken NOTIFY stateChanged) Q_PROPERTY(bool isLoggedIn READ isLoggedIn NOTIFY stateChanged STORED false) Q_PROPERTY(QString defaultRoomVersion READ defaultRoomVersion NOTIFY capabilitiesLoaded) Q_PROPERTY(QUrl homeserver READ homeserver WRITE setHomeserver NOTIFY homeserverChanged) Q_PROPERTY(QVector loginFlows READ loginFlows NOTIFY loginFlowsChanged) Q_PROPERTY(bool isUsable READ isUsable NOTIFY loginFlowsChanged STORED false) Q_PROPERTY(bool supportsSso READ supportsSso NOTIFY loginFlowsChanged STORED false) Q_PROPERTY(bool supportsPasswordAuth READ supportsPasswordAuth NOTIFY loginFlowsChanged STORED false) Q_PROPERTY(bool cacheState READ cacheState WRITE setCacheState NOTIFY cacheStateChanged) Q_PROPERTY(bool lazyLoading READ lazyLoading WRITE setLazyLoading NOTIFY lazyLoadingChanged) public: using UsersToDevicesToEvents = UnorderedMap>; enum RoomVisibility { PublishRoom, UnpublishRoom }; // FIXME: Should go inside CreateRoomJob explicit Connection(QObject* parent = nullptr); explicit Connection(const QUrl& server, QObject* parent = nullptr); ~Connection() override; /// Get all Invited and Joined rooms /*! * \return a hashmap from a composite key - room name and whether * it's an Invite rather than Join - to room pointers * \sa allRooms, rooms, roomsWithTag */ [[deprecated("Use allRooms(), roomsWithTag() or rooms(joinStates) instead")]] QHash, Room*> roomMap() const; /// Get all rooms known within this Connection /*! * This includes Invite, Join and Leave rooms, in no particular order. * \note Leave rooms will only show up in the list if they have been left * in the same running session. The library doesn't cache left rooms * between runs and it doesn't retrieve the full list of left rooms * from the server. * \sa rooms, room, roomsWithTag */ Q_INVOKABLE QVector allRooms() const; /// Get rooms that have either of the given join state(s) /*! * This method returns, in no particular order, rooms which join state * matches the mask passed in \p joinStates. * \note Similar to allRooms(), this won't retrieve the full list of * Leave rooms from the server. * \sa allRooms, room, roomsWithTag */ Q_INVOKABLE QVector rooms(Quotient::JoinStates joinStates) const; /// Get the total number of rooms in the given join state(s) Q_INVOKABLE int roomsCount(Quotient::JoinStates joinStates) const; /** Check whether the account has data of the given type * Direct chats map is not supported by this method _yet_. */ bool hasAccountData(const QString& type) const; /** Get a generic account data event of the given type * This returns an account data event of the given type * stored on the server. Direct chats map cannot be retrieved * using this method _yet_; use directChats() instead. */ const EventPtr& accountData(const QString& type) const; /** Get a generic account data event of the given type * This returns an account data event of the given type * stored on the server. Direct chats map cannot be retrieved * using this method _yet_; use directChats() instead. */ template const typename EventT::content_type accountData() const { if (const auto& eventPtr = accountData(EventT::matrixTypeId())) return eventPtr->content(); return {}; } /** Get account data as a JSON object * This returns the content part of the account data event * of the given type. Direct chats map cannot be retrieved using * this method _yet_; use directChats() instead. */ Q_INVOKABLE QJsonObject accountDataJson(const QString& type) const; /** Set a generic account data event of the given type */ void setAccountData(EventPtr&& event); Q_INVOKABLE void setAccountData(const QString& type, const QJsonObject& content); /** Get all Invited and Joined rooms grouped by tag * \return a hashmap from tag name to a vector of room pointers, * sorted by their order in the tag - details are at * https://matrix.org/speculator/spec/drafts%2Fe2e/client_server/unstable.html#id95 */ QHash> tagsToRooms() const; /** Get all room tags known on this connection */ QStringList tagNames() const; /** Get the list of rooms with the specified tag */ QVector roomsWithTag(const QString& tagName) const; /*! \brief Mark the room as a direct chat with the user * * This function marks \p room as a direct chat with \p user. * Emits the signal synchronously, without waiting to complete * synchronisation with the server. * * \sa directChatsListChanged */ void addToDirectChats(const Room* room, User* user); /*! \brief Unmark the room from direct chats * * This function removes the room id from direct chats either for * a specific \p user or for all users if \p user in nullptr. * The room id is used to allow removal of, e.g., ids of forgotten * rooms; a Room object need not exist. Emits the signal * immediately, without waiting to complete synchronisation with * the server. * * \sa directChatsListChanged */ void removeFromDirectChats(const QString& roomId, User* user = nullptr); /** Check whether the room id corresponds to a direct chat */ bool isDirectChat(const QString& roomId) const; /** Get the whole map from users to direct chat rooms */ DirectChatsMap directChats() const; /** Retrieve the list of users the room is a direct chat with * @return The list of users for which this room is marked as * a direct chat; an empty list if the room is not a direct chat */ QList directChatUsers(const Room* room) const; /** Check whether a particular user is in the ignore list */ Q_INVOKABLE bool isIgnored(const Quotient::User* user) const; /** Get the whole list of ignored users */ Q_INVOKABLE Quotient::IgnoredUsersList ignoredUsers() const; /** Add the user to the ignore list * The change signal is emitted synchronously, without waiting * to complete synchronisation with the server. * * \sa ignoredUsersListChanged */ Q_INVOKABLE void addToIgnoredUsers(const Quotient::User* user); /** Remove the user from the ignore list */ /** Similar to adding, the change signal is emitted synchronously. * * \sa ignoredUsersListChanged */ Q_INVOKABLE void removeFromIgnoredUsers(const Quotient::User* user); /** Get the full list of users known to this account */ QMap users() const; /** Get the base URL of the homeserver to connect to */ QUrl homeserver() const; /** Get the domain name used for ids/aliases on the server */ QString domain() const; /** Check if the homeserver is known to be reachable and working */ bool isUsable() const; /** Get the list of supported login flows */ QVector loginFlows() const; /** Check whether the current homeserver supports password auth */ bool supportsPasswordAuth() const; /** Check whether the current homeserver supports SSO */ bool supportsSso() const; /** Find a room by its id and a mask of applicable states */ Q_INVOKABLE Quotient::Room* room(const QString& roomId, Quotient::JoinStates states = JoinState::Invite | JoinState::Join) const; /** Find a room by its alias and a mask of applicable states */ Q_INVOKABLE Quotient::Room* roomByAlias(const QString& roomAlias, Quotient::JoinStates states = JoinState::Invite | JoinState::Join) const; /** Update the internal map of room aliases to IDs */ /// This is used to maintain the internal index of room aliases. /// It does NOT change aliases on the server, /// \sa Room::setLocalAliases void updateRoomAliases(const QString& roomId, const QStringList& previousRoomAliases, const QStringList& roomAliases); Q_INVOKABLE Quotient::Room* invitation(const QString& roomId) const; Q_INVOKABLE Quotient::User* user(const QString& uId); const User* user() const; User* user(); QString userId() const; QString deviceId() const; QByteArray accessToken() const; bool isLoggedIn() const; #ifdef Quotient_E2EE_ENABLED QtOlm::Account* olmAccount() const; #endif // Quotient_E2EE_ENABLED Q_INVOKABLE Quotient::SyncJob* syncJob() const; Q_INVOKABLE int millisToReconnect() const; Q_INVOKABLE void getTurnServers(); struct SupportedRoomVersion { QString id; QString status; static const QString StableTag; // "stable", as of CS API 0.5 bool isStable() const { return status == StableTag; } friend QDebug operator<<(QDebug dbg, const SupportedRoomVersion& v) { QDebugStateSaver _(dbg); return dbg.nospace() << v.id << '/' << v.status; } }; /// Get the room version recommended by the server /** Only works after server capabilities have been loaded. * \sa loadingCapabilities */ QString defaultRoomVersion() const; /// Get the room version considered stable by the server /** Only works after server capabilities have been loaded. * \sa loadingCapabilities */ QStringList stableRoomVersions() const; /// Get all room versions supported by the server /** Only works after server capabilities have been loaded. * \sa loadingCapabilities */ QVector availableRoomVersions() const; /// Indicate if the user can change its password from the client. /// This is often not the case when SSO is enabled. /// \sa loadingCapabilities bool canChangePassword() const; /** * Call this before first sync to load from previously saved file. * * \param fromFile A local path to read the state from. Uses QUrl * to be QML-friendly. Empty parameter means saving to the directory * defined by stateCachePath() / stateCacheDir(). */ Q_INVOKABLE void loadState(); /** * This method saves the current state of rooms (but not messages * in them) to a local cache file, so that it could be loaded by * loadState() on a next run of the client. * * \param toFile A local path to save the state to. Uses QUrl to be * QML-friendly. Empty parameter means saving to the directory * defined by stateCachePath() / stateCacheDir(). */ Q_INVOKABLE void saveState() const; /// This method saves the current state of a single room. void saveRoomState(Room* r) const; /// Get the default directory path to save the room state to /** \sa stateCacheDir */ Q_INVOKABLE QString stateCachePath() const; /// Get the default directory to save the room state to /** * This function returns the default directory to store the cached * room state, defined as follows: * \code * QStandardPaths::writeableLocation(QStandardPaths::CacheLocation) + * _safeUserId + "_state.json" \endcode where `_safeUserId` is userId() with * `:` (colon) replaced by * `_` (underscore), as colons are reserved characters on Windows. * \sa loadState, saveState, stateCachePath */ QDir stateCacheDir() const; /** Whether or not the rooms state should be cached locally * \sa loadState(), saveState() */ bool cacheState() const; void setCacheState(bool newValue); bool lazyLoading() const; void setLazyLoading(bool newValue); /*! Start a pre-created job object on this connection */ Q_INVOKABLE BaseJob* run(BaseJob* job, RunningPolicy runningPolicy = ForegroundRequest); /*! Start a job of a specified type with specified arguments and policy * * This is a universal method to create and start a job of a type passed * as a template parameter. The policy allows to fine-tune the way * the job is executed - as of this writing it means a choice * between "foreground" and "background". * * \param runningPolicy controls how the job is executed * \param jobArgs arguments to the job constructor * * \sa BaseJob::isBackground. QNetworkRequest::BackgroundRequestAttribute */ template JobT* callApi(RunningPolicy runningPolicy, JobArgTs&&... jobArgs) { auto job = new JobT(std::forward(jobArgs)...); run(job, runningPolicy); return job; } /*! Start a job of a specified type with specified arguments * * This is an overload that runs the job with "foreground" policy. */ template JobT* callApi(JobArgTs&&... jobArgs) { return callApi(ForegroundRequest, std::forward(jobArgs)...); } /*! Get a request URL for a job with specified type and arguments * * This calls JobT::makeRequestUrl() prepending the connection's homeserver * to the list of arguments. */ template QUrl getUrlForApi(JobArgTs&&... jobArgs) const { return JobT::makeRequestUrl(homeserver(), std::forward(jobArgs)...); } Q_INVOKABLE SsoSession* prepareForSso(const QString& initialDeviceName, const QString& deviceId = {}); /** Generate a new transaction id. Transaction id's are unique within * a single Connection object */ Q_INVOKABLE QByteArray generateTxnId() const; /// Set a room factory function static void setRoomFactory(room_factory_t f); /// Set a user factory function static void setUserFactory(user_factory_t f); /// Get a room factory function static room_factory_t roomFactory(); /// Get a user factory function static user_factory_t userFactory(); /// Set the room factory to default with the overriden room type template static void setRoomType() { setRoomFactory(defaultRoomFactory()); } /// Set the user factory to default with the overriden user type template static void setUserType() { setUserFactory(defaultUserFactory()); } public Q_SLOTS: /** Set the homeserver base URL */ void setHomeserver(const QUrl& baseUrl); /** Determine and set the homeserver from MXID */ void resolveServer(const QString& mxid); /** \brief Log in using a username and password pair * * Before logging in, this method checks if the homeserver is valid and * supports the password login flow. If the homeserver is invalid but * a full user MXID is provided, this method calls resolveServer() using * this MXID. * * \sa resolveServer, resolveError, loginError */ void loginWithPassword(const QString& userId, const QString& password, const QString& initialDeviceName, const QString& deviceId = {}); /** \brief Log in using a login token * * One usual case for this method is the final stage of logging in via SSO. * Unlike loginWithPassword() and assumeIdentity(), this method cannot * resolve the server from the user name because the full user MXID is * encoded in the login token. Callers should ensure the homeserver * sanity in advance. */ void loginWithToken(const QByteArray& loginToken, const QString& initialDeviceName, const QString& deviceId = {}); /** \brief Use an existing access token to connect to the homeserver * * Similar to loginWithPassword(), this method checks that the homeserver * URL is valid and tries to resolve it from the MXID in case it is not. */ void assumeIdentity(const QString& mxId, const QString& accessToken, const QString& deviceId); /*! \deprecated Use loginWithPassword instead */ void connectToServer(const QString& userId, const QString& password, const QString& initialDeviceName, const QString& deviceId = {}) { loginWithPassword(userId, password, initialDeviceName, deviceId); } /*! \deprecated * Use assumeIdentity() if you have an access token or * loginWithToken() if you have a login token. */ void connectWithToken(const QString& userId, const QString& accessToken, const QString& deviceId) { assumeIdentity(userId, accessToken, deviceId); } /// Explicitly request capabilities from the server void reloadCapabilities(); /// Find out if capabilites are still loading from the server bool loadingCapabilities() const; /** @deprecated Use stopSync() instead */ void disconnectFromServer() { stopSync(); } void logout(); void sync(int timeout = -1); void syncLoop(int timeout = 30000); void stopSync(); QString nextBatchToken() const; virtual MediaThumbnailJob* getThumbnail(const QString& mediaId, QSize requestedSize, RunningPolicy policy = BackgroundRequest); MediaThumbnailJob* getThumbnail(const QUrl& url, QSize requestedSize, RunningPolicy policy = BackgroundRequest); MediaThumbnailJob* getThumbnail(const QUrl& url, int requestedWidth, int requestedHeight, RunningPolicy policy = BackgroundRequest); // QIODevice* should already be open UploadContentJob* uploadContent(QIODevice* contentSource, const QString& filename = {}, const QString& overrideContentType = {}); UploadContentJob* uploadFile(const QString& fileName, const QString& overrideContentType = {}); GetContentJob* getContent(const QString& mediaId); GetContentJob* getContent(const QUrl& url); // If localFilename is empty, a temporary file will be created DownloadFileJob* downloadFile(const QUrl& url, const QString& localFilename = {}); /** * \brief Create a room (generic method) * This method allows to customize room entirely to your liking, * providing all the attributes the original CS API provides. */ CreateRoomJob* createRoom(RoomVisibility visibility, const QString& alias, const QString& name, const QString& topic, QStringList invites, const QString& presetName = {}, const QString& roomVersion = {}, bool isDirect = false, const QVector& initialState = {}, const QVector& invite3pids = {}, const QJsonObject& creationContent = {}); /** Get a direct chat with a single user * This method may return synchronously or asynchoronously depending * on whether a direct chat room with the respective person exists * already. * * \sa directChatAvailable */ void requestDirectChat(const QString& userId); /** Get a direct chat with a single user * This method may return synchronously or asynchoronously depending * on whether a direct chat room with the respective person exists * already. * * \sa directChatAvailable */ void requestDirectChat(User* u); /** Run an operation in a direct chat with the user * This method may return synchronously or asynchoronously depending * on whether a direct chat room with the respective person exists * already. Instead of emitting a signal it executes the passed * function object with the direct chat room as its parameter. */ void doInDirectChat(const QString& userId, const std::function& operation); /** Run an operation in a direct chat with the user * This method may return synchronously or asynchoronously depending * on whether a direct chat room with the respective person exists * already. Instead of emitting a signal it executes the passed * function object with the direct chat room as its parameter. */ void doInDirectChat(User* u, const std::function& operation); /** Create a direct chat with a single user, optional name and topic * A room will always be created, unlike in requestDirectChat. * It is advised to use requestDirectChat as a default way of getting * one-on-one with a person, and only use createDirectChat when * a new creation is explicitly desired. */ CreateRoomJob* createDirectChat(const QString& userId, const QString& topic = {}, const QString& name = {}); virtual JoinRoomJob* joinRoom(const QString& roomAlias, const QStringList& serverNames = {}); /** Sends /forget to the server and also deletes room locally. * This method is in Connection, not in Room, since it's a * room lifecycle operation, and Connection is an acting room manager. * It ensures that the local user is not a member of a room (running /leave, * if necessary) then issues a /forget request and if that one doesn't fail * deletion of the local Room object is ensured. * \param id - the room id to forget * \return - the ongoing /forget request to the server; note that the * success() signal of this request is connected to deleteLater() * of a respective room so by the moment this finishes, there might be no * Room object anymore. */ ForgetRoomJob* forgetRoom(const QString& id); SendToDeviceJob* sendToDevices(const QString& eventType, const UsersToDevicesToEvents& eventsMap); /** \deprecated This method is experimental and may be removed any time */ SendMessageJob* sendMessage(const QString& roomId, const RoomEvent& event); /** \deprecated Do not use this directly, use Room::leaveRoom() instead */ virtual LeaveRoomJob* leaveRoom(Room* room); // Old API that will be abolished any time soon. DO NOT USE. /** @deprecated Use callApi() or Room::postReceipt() instead */ virtual PostReceiptJob* postReceipt(Room* room, RoomEvent* event); Q_SIGNALS: /** * @deprecated * This was a signal resulting from a successful resolveServer(). * Since Connection now provides setHomeserver(), the HS URL * may change even without resolveServer() invocation. Use * loginFLowsChanged() instead of resolved(). You can also use * loginWith*() and assumeIdentity() without the HS URL set in * advance (i.e. without calling resolveServer), as they trigger * server name resolution from MXID if the server URL is not valid. */ void resolved(); void resolveError(QString error); void homeserverChanged(QUrl baseUrl); void loginFlowsChanged(); void capabilitiesLoaded(); void connected(); void reconnected(); //< \deprecated Use connected() instead void loggedOut(); /** Login data or state have changed * * This is a common change signal for userId, deviceId and * accessToken - these properties normally only change at * a successful login and logout and are constant at other times. */ void stateChanged(); void loginError(QString message, QString details); /** A network request (job) failed * * @param request - the pointer to the failed job */ void requestFailed(Quotient::BaseJob* request); /** A network request (job) failed due to network problems * * This is _only_ emitted when the job will retry on its own; * once it gives up, requestFailed() will be emitted. * * @param message - message about the network problem * @param details - raw error details, if any available * @param retriesTaken - how many retries have already been taken * @param nextRetryInMilliseconds - when the job will retry again */ void networkError(QString message, QString details, int retriesTaken, int nextRetryInMilliseconds); void syncDone(); void syncError(QString message, QString details); void newUser(Quotient::User* user); /** * \group Signals emitted on room transitions * * Note: Rooms in Invite state are always stored separately from * rooms in Join/Leave state, because of special treatment of * invite_state in Matrix CS API (see The Spec on /sync for details). * Therefore, objects below are: r - room in Join/Leave state; * i - room in Invite state * * 1. none -> Invite: newRoom(r), invitedRoom(r,nullptr) * 2. none -> Join: newRoom(r), joinedRoom(r,nullptr) * 3. none -> Leave: newRoom(r), leftRoom(r,nullptr) * 4. Invite -> Join: * newRoom(r), joinedRoom(r,i), aboutToDeleteRoom(i) * 4a. Leave and Invite -> Join: * joinedRoom(r,i), aboutToDeleteRoom(i) * 5. Invite -> Leave: * newRoom(r), leftRoom(r,i), aboutToDeleteRoom(i) * 5a. Leave and Invite -> Leave: * leftRoom(r,i), aboutToDeleteRoom(i) * 6. Join -> Leave: leftRoom(r) * 7. Leave -> Invite: newRoom(i), invitedRoom(i,r) * 8. Leave -> Join: joinedRoom(r) * The following transitions are only possible via forgetRoom() * so far; if a room gets forgotten externally, sync won't tell * about it: * 9. any -> none: as any -> Leave, then aboutToDeleteRoom(r) */ /** A new room object has been created */ void newRoom(Quotient::Room* room); /** A room invitation is seen for the first time * * If the same room is in Left state, it's passed in prev. Beware * that initial sync will trigger this signal for all rooms in * Invite state. */ void invitedRoom(Quotient::Room* room, Quotient::Room* prev); /** A joined room is seen for the first time * * It's not the same as receiving a room in "join" section of sync * response (rooms will be there even after joining); it's also * not (exactly) the same as actual joining action of a user (all * rooms coming in initial sync will trigger this signal too). If * this room was in Invite state before, the respective object is * passed in prev (and it will be deleted shortly afterwards). */ void joinedRoom(Quotient::Room* room, Quotient::Room* prev); /** A room has just been left * * If this room has been in Invite state (as in case of rejecting * an invitation), the respective object will be passed in prev * (and will be deleted shortly afterwards). Note that, similar * to invitedRoom and joinedRoom, this signal is triggered for all * Left rooms upon initial sync (not only those that were left * right before the sync). */ void leftRoom(Quotient::Room* room, Quotient::Room* prev); /** The room object is about to be deleted */ void aboutToDeleteRoom(Quotient::Room* room); /** The room has just been created by createRoom or requestDirectChat * * This signal is not emitted in usual room state transitions, * only as an outcome of room creation operations invoked by * the client. * \note requestDirectChat doesn't necessarily create a new chat; * use directChatAvailable signal if you just need to obtain * a direct chat room. */ void createdRoom(Quotient::Room* room); /** The first sync for the room has been completed * * This signal is emitted after the room has been synced the first * time. This is the right signal to connect to if you need to * access the room state (name, aliases, members); state transition * signals (newRoom, joinedRoom etc.) come earlier, when the room * has just been created. */ void loadedRoomState(Quotient::Room* room); /** Account data (except direct chats) have changed */ void accountDataChanged(QString type); /** The direct chat room is ready for using * This signal is emitted upon any successful outcome from * requestDirectChat. */ void directChatAvailable(Quotient::Room* directChat); /** The list of direct chats has changed * This signal is emitted every time when the mapping of users * to direct chat rooms is changed (because of either local updates * or a different list arrived from the server). */ void directChatsListChanged(Quotient::DirectChatsMap additions, Quotient::DirectChatsMap removals); void ignoredUsersListChanged(Quotient::IgnoredUsersList additions, Quotient::IgnoredUsersList removals); void cacheStateChanged(); void lazyLoadingChanged(); void turnServersChanged(const QJsonObject& servers); protected: /** * @brief Access the underlying ConnectionData class */ const ConnectionData* connectionData() const; /** Get a Room object for the given id in the given state * * Use this method when you need a Room object in the local list * of rooms, with the given state. Note that this does not interact * with the server; in particular, does not automatically create * rooms on the server. This call performs necessary join state * transitions; e.g., if it finds a room in Invite but * `joinState == JoinState::Join` then the Invite room object * will be deleted and a new room object with Join state created. * In contrast, switching between Join and Leave happens within * the same object. * \param roomId room id (not alias!) * \param joinState desired (target) join state of the room; if * omitted, any state will be found and return unchanged, or a * new Join room created. * @return a pointer to a Room object with the specified id and the * specified state; nullptr if roomId is empty or if roomFactory() * failed to create a Room object. */ Room* provideRoom(const QString& roomId, Omittable joinState = none); /** * Completes loading sync data. */ void onSyncSuccess(SyncData&& data, bool fromCache = false); protected Q_SLOTS: void syncLoopIteration(); private: class Private; QScopedPointer d; static room_factory_t _roomFactory; static user_factory_t _userFactory; }; } // namespace Quotient Q_DECLARE_METATYPE(Quotient::DirectChatsMap) Q_DECLARE_METATYPE(Quotient::IgnoredUsersList)