conversation.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2026 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 "jamidht/conversationrepository.h"
#include "conversationrepository.h"
#include "swarm/swarm_protocol.h"
#include "jami/conversation_interface.h"
#include "jamidht/typers.h"
#include "string_utils.h"
 
#include <json/json.h>
#include <msgpack.hpp>
 
#include <functional>
#include <string>
#include <vector>
#include <map>
#include <memory>
#include <set>
 
#include <asio.hpp>
 
namespace dhtnet {
class ChannelSocket;
} // namespace dhtnet
 
namespace jami {
 
namespace ConversationMapKeys {
static constexpr const char* ID {"id"};
static constexpr const char* CREATED {"created"};
static constexpr const char* REMOVED {"removed"};
static constexpr const char* ERASED {"erased"};
static constexpr const char* MEMBERS {"members"};
static constexpr const char* LAST_DISPLAYED {"lastDisplayed"};
static constexpr const char* RECEIVED {"received"};
static constexpr const char* DECLINED {"declined"};
static constexpr const char* FROM {"from"};
static constexpr const char* CONVERSATIONID {"conversationId"};
static constexpr const char* METADATAS {"metadatas"};
} // namespace ConversationMapKeys
 
namespace ConversationDirectories {
static constexpr std::string_view PREFERENCES {"preferences"};
static constexpr std::string_view STATUS {"status"};
static constexpr std::string_view SENDING {"sending"};
static constexpr std::string_view FETCHED {"fetched"};
static constexpr std::string_view ACTIVE_CALLS {"activeCalls"};
static constexpr std::string_view HOSTED_CALLS {"hostedCalls"};
static constexpr std::string_view CACHED {"cached"};
} // namespace ConversationDirectories
 
namespace ConversationPreferences {
static constexpr const char* HOST_CONFERENCES = "hostConferences";
}
 
class JamiAccount;
class ConversationRepository;
class TransferManager;
enum class ConversationMode;
 
struct ConversationRequest
{
    std::string conversationId;
    std::string from;
    std::map<std::string, std::string> metadatas;
 
    time_t received {0};
    time_t declined {0};
 
    ConversationRequest() = default;
    ConversationRequest(const Json::Value& json);
 
    Json::Value toJson() const;
    std::map<std::string, std::string> toMap() const;
 
    bool operator==(const ConversationRequest& o) const
    {
        auto m = toMap();
        auto om = o.toMap();
        return m.size() == om.size() && std::equal(m.begin(), m.end(), om.begin());
    }
 
    bool isOneToOne() const
    {
        try {
            return metadatas.at("mode") == "0";
        } catch (...) {
        }
        return true;
    }
 
    ConversationMode mode() const
    {
        try {
            return to_enum<ConversationMode>(metadatas.at("mode"));
        } catch (...) {
        }
        return ConversationMode::ONE_TO_ONE;
    }
 
    MSGPACK_DEFINE_MAP(from, conversationId, metadatas, received, declined)
};
 
struct ConvInfo
{
    std::string id {};
    time_t created {0};
    time_t removed {0};
    time_t erased {0};
    std::set<std::string> members;
    std::string lastDisplayed {};
    ConversationMode mode {0};
 
    ConvInfo() = default;
    ConvInfo(const ConvInfo&) = default;
    ConvInfo(ConvInfo&&) = default;
    ConvInfo(const std::string& id)
        : id(id) {};
    explicit ConvInfo(const Json::Value& json);
 
    bool isRemoved() const { return removed >= created; }
 
    ConvInfo& operator=(const ConvInfo&) = default;
    ConvInfo& operator=(ConvInfo&&) = default;
 
    Json::Value toJson() const;
 
    MSGPACK_DEFINE_MAP(id, created, removed, erased, members, lastDisplayed, mode)
};
 
using OnPullCb = std::function<void(bool fetchOk)>;
using OnLoadMessages = std::function<void(std::vector<libjami::SwarmMessage>&& messages)>;
using OnCommitCb = std::function<void(const std::string&)>;
using OnDoneCb = std::function<void(bool, const std::string&)>;
using OnMembersChanged = std::function<void(const std::set<std::string>&)>;
using DeviceId = dht::PkId;
using GitSocketList = std::map<DeviceId, std::shared_ptr<dhtnet::ChannelSocket>>;
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&)>;
 
class Conversation : public std::enable_shared_from_this<Conversation>
{
public:
    Conversation(const std::shared_ptr<JamiAccount>& account,
                 ConversationMode mode,
                 const std::string& otherMember = "");
    Conversation(const std::shared_ptr<JamiAccount>& account, const std::string& conversationId = "");
    Conversation(const std::shared_ptr<JamiAccount>& account,
                 const std::string& remoteDevice,
                 const std::string& conversationId);
    ~Conversation();
 
    void monitor();
 
#ifdef LIBJAMI_TEST
    enum class BootstrapStatus { FAILED, FALLBACK, SUCCESS };
    void onBootstrapStatus(const std::function<void(std::string, BootstrapStatus)>& cb);
 
    std::vector<libjami::SwarmMessage> loadMessagesSync(const LogOptions& options);
    void announce(const std::vector<std::map<std::string, std::string>>& commits, bool commitFromSelf = false);
    void announce(const std::string& commitId, bool commitFromSelf = false);
#endif
 
    void bootstrap(std::function<void()> onBootstrapped, const std::vector<DeviceId>& knownDevices = {});
 
    void addKnownDevices(const std::vector<DeviceId>& devices, const std::string& memberUri);
 
    std::vector<std::string> commitsEndedCalls();
 
    void onMembersChanged(OnMembersChanged&& cb);
 
    void onNeedSocket(NeedSocketCb cb);
    void addSwarmChannel(std::shared_ptr<dhtnet::ChannelSocket> channel);
 
    std::string id() const;
 
    // Member management
    void addMember(const std::string& contactUri, const OnDoneCb& cb = {});
    void removeMember(const std::string& contactUri, bool isDevice, const OnDoneCb& cb = {});
    std::vector<std::map<std::string, std::string>> getMembers(bool includeInvited = false,
                                                               bool includeLeft = false,
                                                               bool includeBanned = false) const;
 
    std::set<std::string> memberUris(std::string_view filter = {},
                                     const std::set<MemberRole>& filteredRoles = {MemberRole::INVITED,
                                                                                  MemberRole::LEFT,
                                                                                  MemberRole::BANNED}) const;
 
    std::vector<std::map<std::string, std::string>> getTrackedMembers() const;
 
    std::vector<NodeId> peersToSyncWith() const;
    bool isBootstrapped() const;
    std::string uriFromDevice(const std::string& deviceId) const;
 
    std::string join();
 
    bool isMember(const std::string& uri, bool includeInvited = false) const;
    bool isBanned(const std::string& uri) const;
 
    // Message send
    void sendMessage(Json::Value&& message,
                     const std::string& replyTo = "",
                     OnCommitCb&& onCommit = {},
                     OnDoneCb&& cb = {});
    void loadMessages(const OnLoadMessages& cb, const LogOptions& options);
    void clearCache();
    bool hasCommit(const std::string& commitId) const;
    std::optional<std::map<std::string, std::string>> getCommit(const std::string& commitId) const;
    std::string lastCommitId() const;
 
    bool pull(const std::string& deviceId, OnPullCb&& cb, std::string commitId = "");
    void sync(const std::string& member, const std::string& deviceId, OnPullCb&& cb, std::string commitId = "");
 
    std::map<std::string, std::string> generateInvitation() const;
 
    std::string leave();
 
    void setRemovingFlag();
 
    bool isRemoving();
 
    void erase();
 
    ConversationMode mode() const;
 
    std::vector<std::string> getInitialMembers() const;
    bool isInitialMember(const std::string& uri) const;
 
    void updateInfos(const std::map<std::string, std::string>& map, const OnDoneCb& cb = {});
 
    void updatePreferences(const std::map<std::string, std::string>& map);
 
    std::map<std::string, std::string> infos() const;
    std::map<std::string, std::string> preferences(bool includeLastModified) const;
    std::vector<uint8_t> vCard() const;
 
 
    std::shared_ptr<TransferManager> dataTransfer() const;
 
    bool onFileChannelRequest(const std::string& member,
                              const std::string& fileId,
                              std::filesystem::path& path,
                              std::string& sha3sum) const;
    bool downloadFile(const std::string& interactionId,
                      const std::string& fileId,
                      const std::string& path,
                      const std::string& member = "",
                      const std::string& deviceId = "");
 
    void clearFetched();
    void hasFetched(const std::string& deviceId, const std::string& commitId);
 
    bool setMessageDisplayed(const std::string& uri, const std::string& interactionId);
    std::map<std::string, std::map<std::string, std::string>> messageStatus() const;
    void updateMessageStatus(const std::map<std::string, std::map<std::string, std::string>>& messageStatus);
    void onMessageStatusChanged(
        const std::function<void(const std::map<std::string, std::map<std::string, std::string>>&)>& cb);
    uint32_t countInteractions(const std::string& toId,
                               const std::string& fromId = "",
                               const std::string& authorUri = "") const;
    void search(uint32_t req, const Filter& filter, const std::shared_ptr<std::atomic_int>& flag) const;
    void hostConference(Json::Value&& message, OnDoneCb&& cb = {});
    void removeActiveConference(Json::Value&& message, OnDoneCb&& cb = {});
    bool isHosting(const std::string& confId) const;
    std::vector<std::map<std::string, std::string>> currentCalls() const;
 
    std::shared_ptr<dhtnet::ChannelSocket> gitSocket(const DeviceId& deviceId) const;
    void addGitSocket(const DeviceId& deviceId, const std::shared_ptr<dhtnet::ChannelSocket>& socket);
    void removeGitSocket(const DeviceId& deviceId);
 
    void shutdownConnections();
    bool hasSwarmChannel(const std::string& deviceId);
 
    void connectivityChanged();
 
    std::vector<jami::DeviceId> getDeviceIdList() const;
 
    std::shared_ptr<Typers> typers() const;
 
    std::vector<std::map<std::string, std::string>> getConnectivity() const;
 
private:
    std::shared_ptr<Conversation> shared() { return std::static_pointer_cast<Conversation>(shared_from_this()); }
    std::shared_ptr<Conversation const> shared() const
    {
        return std::static_pointer_cast<Conversation const>(shared_from_this());
    }
    std::weak_ptr<Conversation> weak() { return std::static_pointer_cast<Conversation>(shared_from_this()); }
    std::weak_ptr<Conversation const> weak() const
    {
        return std::static_pointer_cast<Conversation const>(shared_from_this());
    }
 
    // Private because of weak()
    class Impl;
    std::unique_ptr<Impl> pimpl_;
};
 
} // namespace jami