conversation_module.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2025 Savoir-faire Linux Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include "scheduled_executor.h"
#include "jamidht/account_manager.h"
#include "jamidht/conversation.h"
#include "jamidht/conversationrepository.h"
#include "jamidht/jami_contact.h"
 
#include <mutex>
#include <msgpack.hpp>
 
namespace jami {
static constexpr const char MIME_TYPE_INVITE[] {"application/invite"};
static constexpr const char MIME_TYPE_GIT[] {"application/im-gitmessage-id"};
 
class SIPCall;
 
struct SyncMsg
{
    DeviceSync ds;
    std::map<std::string, ConvInfo> c;
    std::map<std::string, ConversationRequest> cr;
    // p is conversation's preferences. It's not stored in c, as
    // we can update the preferences without touching any confInfo.
    std::map<std::string, std::map<std::string, std::string>> p;
    // Last displayed messages [[deprecated]]
    std::map<std::string, std::map<std::string, std::string>> ld;
    // Read & fetched status
    /*
     * {{ convId,
     *      { memberUri,, {
     *          {"fetch", "commitId"},
     *          {"fetched_ts", "timestamp"},
     *          {"read", "commitId"},
     *          {"read_ts", "timestamp"}
     *       }
     * }}
     */
    std::map<std::string, std::map<std::string, std::map<std::string, std::string>>> ms;
 
    MSGPACK_DEFINE(ds, c, cr, p, ld, ms)
};
 
using ChannelCb = std::function<bool(const std::shared_ptr<dhtnet::ChannelSocket>&)>;
using NeedSocketCb
    = std::function<void(const std::string&, const std::string&, ChannelCb&&, const std::string&)>;
using SengMsgCb = std::function<
    uint64_t(const std::string&, const DeviceId&, std::map<std::string, std::string>, uint64_t)>;
using NeedsSyncingCb = std::function<void(std::shared_ptr<SyncMsg>&&)>;
using OneToOneRecvCb = std::function<void(const std::string&, const std::string&)>;
 
class ConversationModule
{
public:
    ConversationModule(std::shared_ptr<JamiAccount> account,
                       std::shared_ptr<AccountManager> accountManager,
                       NeedsSyncingCb&& needsSyncingCb,
                       SengMsgCb&& sendMsgCb,
                       NeedSocketCb&& onNeedSocket,
                       NeedSocketCb&& onNeedSwarmSocket,
                       OneToOneRecvCb&& oneToOneRecvCb,
                       bool autoLoadConversations = true);
    ~ConversationModule() = default;
 
    void setAccountManager(std::shared_ptr<AccountManager> accountManager);
 
    void loadConversations();
 
    void loadSingleConversation(const std::string& convId);
 
#ifdef LIBJAMI_TEST
    void onBootstrapStatus(const std::function<void(std::string, Conversation::BootstrapStatus)>& cb);
#endif
 
    void monitor();
 
    void bootstrap(const std::string& convId = "");
 
    void clearPendingFetch();
 
    void reloadRequests();
 
    std::vector<std::string> getConversations() const;
 
    std::string getOneToOneConversation(const std::string& uri) const noexcept;
 
    bool updateConvForContact(const std::string& uri,
                              const std::string& oldConv,
                              const std::string& newConv);
 
    std::vector<std::map<std::string, std::string>> getConversationRequests() const;
 
    void onTrustRequest(const std::string& uri,
                        const std::string& conversationId,
                        const std::vector<uint8_t>& payload,
                        time_t received);
 
    void onConversationRequest(const std::string& from, const Json::Value& value);
 
    std::string peerFromConversationRequest(const std::string& convId) const;
 
    void onNeedConversationRequest(const std::string& from, const std::string& conversationId);
 
    void acceptConversationRequest(const std::string& conversationId,
                                   const std::string& deviceId = "");
 
    void declineConversationRequest(const std::string& conversationId);
 
    void cloneConversationFrom(const std::string& conversationId,
                               const std::string& uri,
                               const std::string& oldConvId = "");
 
    std::string startConversation(ConversationMode mode = ConversationMode::INVITES_ONLY,
                                  const dht::InfoHash& otherMember = {});
 
    // Message send/load
    void sendMessage(const std::string& conversationId,
                     Json::Value&& value,
                     const std::string& replyTo = "",
                     bool announce = true,
                     OnCommitCb&& onCommit = {},
                     OnDoneCb&& cb = {});
 
    void sendMessage(const std::string& conversationId,
                     std::string message,
                     const std::string& replyTo = "",
                     const std::string& type = "text/plain",
                     bool announce = true,
                     OnCommitCb&& onCommit = {},
                     OnDoneCb&& cb = {});
 
    void editMessage(const std::string& conversationId,
                     const std::string& newBody,
                     const std::string& editedId);
    void reactToMessage(const std::string& conversationId,
                        const std::string& newBody,
                        const std::string& reactToId);
 
    void addCallHistoryMessage(const std::string& uri, uint64_t duration_ms, const std::string& reason);
 
    // Received that a peer displayed a message
    bool onMessageDisplayed(const std::string& peer,
                            const std::string& conversationId,
                            const std::string& interactionId);
    std::map<std::string, std::map<std::string, std::map<std::string, std::string>>> convMessageStatus() const;
 
    uint32_t loadConversationMessages(const std::string& conversationId,
                                      const std::string& fromMessage = "",
                                      size_t n = 0);
    uint32_t loadConversation(const std::string& conversationId,
                              const std::string& fromMessage = "",
                              size_t n = 0);
    uint32_t loadConversationUntil(const std::string& conversationId,
                                   const std::string& fromMessage,
                                   const std::string& to);
    uint32_t loadSwarmUntil(const std::string& conversationId,
                            const std::string& fromMessage,
                            const std::string& toMessage);
    void clearCache(const std::string& conversationId);
 
    // File transfer
    std::shared_ptr<TransferManager> dataTransfer(const std::string& id) const;
 
    bool onFileChannelRequest(const std::string& conversationId,
                              const std::string& member,
                              const std::string& fileId,
                              bool verifyShaSum = true) const;
 
    bool downloadFile(const std::string& conversationId,
                      const std::string& interactionId,
                      const std::string& fileId,
                      const std::string& path);
 
    // Sync
    void syncConversations(const std::string& peer, const std::string& deviceId);
 
    void onSyncData(const SyncMsg& msg, const std::string& peerId, const std::string& deviceId);
 
    bool needsSyncingWith(const std::string& memberUri, const std::string& deviceId) const;
 
    void setFetched(const std::string& conversationId,
                    const std::string& deviceId,
                    const std::string& commit);
 
    void fetchNewCommits(const std::string& peer,
                         const std::string& deviceId,
                         const std::string& conversationId,
                         const std::string& commitId);
 
    // Conversation's member
    void addConversationMember(const std::string& conversationId,
                               const dht::InfoHash& contactUri,
                               bool sendRequest = true);
    void removeConversationMember(const std::string& conversationId,
                                  const dht::InfoHash& contactUri,
                                  bool isDevice = false);
    std::vector<std::map<std::string, std::string>> getConversationMembers(
        const std::string& conversationId, bool includeBanned = false) const;
    uint32_t countInteractions(const std::string& convId,
                               const std::string& toId,
                               const std::string& fromId,
                               const std::string& authorUri) const;
 
    void search(uint32_t req, const std::string& convId, const Filter& filter) const;
 
    // Conversation's infos management
    void updateConversationInfos(const std::string& conversationId,
                                 const std::map<std::string, std::string>& infos,
                                 bool sync = true);
    std::map<std::string, std::string> conversationInfos(const std::string& conversationId) const;
    void setConversationPreferences(const std::string& conversationId,
                                    const std::map<std::string, std::string>& prefs);
    std::map<std::string, std::string> getConversationPreferences(const std::string& conversationId,
                                                                  bool includeCreated = false) const;
    std::map<std::string, std::map<std::string, std::string>> convPreferences() const;
    // Get the map into a VCard format for storing
    std::vector<uint8_t> conversationVCard(const std::string& conversationId) const;
 
    bool isBanned(const std::string& convId, const std::string& uri) const;
 
    // Remove swarm
    void removeContact(const std::string& uri, bool ban);
 
    bool removeConversation(const std::string& conversationId);
    void initReplay(const std::string& oldConvId, const std::string& newConvId);
    bool isHosting(const std::string& conversationId, const std::string& confId) const;
    std::vector<std::map<std::string, std::string>> getActiveCalls(
        const std::string& conversationId) const;
    std::shared_ptr<SIPCall> call(const std::string& url,
                                const std::vector<libjami::MediaMap>& mediaList,
                                std::function<void(const std::string&, const DeviceId&, const std::shared_ptr<SIPCall>&)>&& cb);
    void hostConference(const std::string& conversationId,
                        const std::string& confId,
                        const std::string& callId,
                        const std::vector<libjami::MediaMap>& mediaList = {});
 
    // The following methods modify what is stored on the disk
    static void saveConvInfos(const std::string& accountId,
                              const std::map<std::string, ConvInfo>& conversations);
    static void saveConvInfosToPath(const std::filesystem::path& path,
                                    const std::map<std::string, ConvInfo>& conversations);
    static void saveConvRequests(
        const std::string& accountId,
        const std::map<std::string, ConversationRequest>& conversationsRequests);
    static void saveConvRequestsToPath(
        const std::filesystem::path& path,
        const std::map<std::string, ConversationRequest>& conversationsRequests);
 
    static std::map<std::string, ConvInfo> convInfos(const std::string& accountId);
    static std::map<std::string, ConvInfo> convInfosFromPath(const std::filesystem::path& path);
    static std::map<std::string, ConversationRequest> convRequests(const std::string& accountId);
    static std::map<std::string, ConversationRequest> convRequestsFromPath(
        const std::filesystem::path& path);
    void addConvInfo(const ConvInfo& info);
 
    std::shared_ptr<Conversation> getConversation(const std::string& convId);
    std::shared_ptr<dhtnet::ChannelSocket> gitSocket(std::string_view deviceId,
                                                     std::string_view convId) const;
    void removeGitSocket(std::string_view deviceId, std::string_view convId);
    void addGitSocket(std::string_view deviceId,
                      std::string_view convId,
                      const std::shared_ptr<dhtnet::ChannelSocket>& channel);
    void shutdownConnections();
    void addSwarmChannel(const std::string& conversationId,
                         std::shared_ptr<dhtnet::ChannelSocket> socket);
    void connectivityChanged();
 
    std::shared_ptr<Typers> getTypers(const std::string& convId);
 
private:
    class Impl;
    std::shared_ptr<Impl> pimpl_;
};
 
} // namespace jami