manager.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
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include "account_factory.h"
#include "call_factory.h"
#include "preferences.h"
#include "media/audio/audiolayer.h"
#include "scheduled_executor.h"
#include "gittransport.h"
#include <dhtnet/certstore.h>
 
#include <algorithm>
#include <atomic>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "trace-tools.h"
 
namespace asio {
class io_context;
}
 
namespace dhtnet {
class ChannelSocket;
class IceTransportFactory;
} // namespace dhtnet
 
namespace jami {
namespace video {
class SinkClient;
class VideoGenerator;
} // namespace video
class RingBufferPool;
struct VideoManager;
class Conference;
class AudioLoop;
class JamiAccount;
class SIPVoIPLink;
class JamiPluginManager;
 
// TODO LIBJAMI_PUBLIC only if tests
class LIBJAMI_TEST_EXPORT Manager
{
private:
    std::mt19937_64 rand_;
 
public:
    // TODO LIBJAMI_PUBLIC only if tests
    static LIBJAMI_TEST_EXPORT Manager& instance();
 
    void setAutoAnswer(bool enable);
 
    Preferences preferences;
 
    VoipPreference voipPreferences;
 
    AudioPreference audioPreference;
 
#ifdef ENABLE_PLUGIN
    PluginPreferences pluginPreferences;
#endif
 
#ifdef ENABLE_VIDEO
    VideoPreferences videoPreferences;
#endif
 
    // Manager should not be accessed until initialized.
    // FIXME this is an evil hack!
    static std::atomic_bool initialized;
 
#if TARGET_OS_IOS
    static bool isIOSExtension;
#endif
 
    static bool syncOnRegister;
 
    static bool autoLoad;
 
    void init(const std::filesystem::path& config_file, libjami::InitFlag flags);
 
    /*
     * Terminate all threads and exit DBus loop
     */
    void finish() noexcept;
 
    void monitor(bool continuous);
 
    std::vector<std::map<std::string, std::string>> getConnectionList(
        const std::string& accountId, const std::string& conversationId);
    std::vector<std::map<std::string, std::string>> getChannelList(const std::string& accountId,
                                                                   const std::string& connectionId);
 
    std::shared_ptr<AudioLayer> getAudioDriver();
 
    inline std::unique_ptr<AudioDeviceGuard> startAudioStream(AudioDeviceType stream)
    {
        return std::make_unique<AudioDeviceGuard>(*this, stream);
    }
 
    std::string outgoingCall(const std::string& accountId,
                             const std::string& callee,
                             const std::vector<libjami::MediaMap>& mediaList = {});
 
    bool answerCall(const std::string& accountId,
                    const std::string& callId,
                    const std::vector<libjami::MediaMap>& mediaList = {});
    bool answerCall(Call& call, const std::vector<libjami::MediaMap>& mediaList = {});
 
    void incomingCall(const std::string& accountId, Call& call);
 
    bool hangupCall(const std::string& accountId, const std::string& callId);
 
    bool hangupConference(const std::string& accountId, const std::string& confId);
 
    bool onHoldCall(const std::string& accountId, const std::string& callId);
 
    bool offHoldCall(const std::string& accountId, const std::string& callId);
 
    bool transferCall(const std::string& accountId, const std::string& id, const std::string& to);
 
    void transferSucceeded();
 
    void transferFailed();
 
    bool refuseCall(const std::string& accountId, const std::string& id);
 
    bool holdConference(const std::string& accountId, const std::string& confId);
 
    bool unHoldConference(const std::string& accountId, const std::string& confId);
 
    bool addSubCall(const std::string& accountId,
                        const std::string& callId,
                        const std::string& account2Id,
                        const std::string& confId);
    bool addSubCall(Call& call, Conference& conference);
    void bindCallToConference(Call& call, Conference& conf);
 
    bool addMainParticipant(const std::string& accountId, const std::string& confId);
 
    bool joinParticipant(const std::string& accountId,
                         const std::string& callId1,
                         const std::string& account2Id,
                         const std::string& callId2,
                         bool attached = true);
 
    void createConfFromParticipantList(const std::string& accountId,
                                       const std::vector<std::string>&);
 
    bool detachParticipant(const std::string& callId);
 
    bool detachHost(const std::shared_ptr<Conference>& conf = {});
 
    void removeParticipant(Call& call);
 
    bool joinConference(const std::string& accountId,
                        const std::string& confId1,
                        const std::string& account2Id,
                        const std::string& confId2);
 
    void addAudio(Call& call);
 
    void removeAudio(Call& call);
 
    void saveConfig();
    void saveConfig(const std::shared_ptr<Account>& acc);
 
    void playTone();
 
    void playToneWithMessage();
 
    void stopTone();
 
    void peerAnsweredCall(Call& call);
 
    void peerRingingCall(Call& call);
 
    void peerHungupCall(Call& call);
 
    void incomingMessage(const std::string& accountId,
                         const std::string& callId,
                         const std::string& from,
                         const std::map<std::string, std::string>& messages);
 
    void sendCallTextMessage(const std::string& accountId,
                             const std::string& callID,
                             const std::map<std::string, std::string>& messages,
                             const std::string& from,
                             bool isMixed);
 
    void sendRegister(const std::string& accountId, bool enable);
 
    uint64_t sendTextMessage(const std::string& accountID,
                             const std::string& to,
                             const std::map<std::string, std::string>& payloads,
                             bool fromPlugin = false,
                             bool onlyConnected = false);
 
    int getMessageStatus(uint64_t id) const;
    int getMessageStatus(const std::string& accountID, uint64_t id) const;
 
    std::vector<std::string> getAccountList() const;
 
    void setAccountsOrder(const std::string& order);
 
    std::map<std::string, std::string> getAccountDetails(const std::string& accountID) const;
 
    std::map<std::string, std::string> getVolatileAccountDetails(const std::string& accountID) const;
 
    std::vector<std::string> getCallList() const;
 
    void setAccountDetails(const std::string& accountID,
                           const std::map<std::string, std::string>& details);
 
    void setAccountActive(const std::string& accountID,
                          bool active,
                          bool shutdownConnections);
    void loadAccountAndConversation(const std::string& accountId,
                                    bool loadAll,
                                    const std::string& convId);
 
    std::mt19937_64 getSeededRandomEngine();
 
    std::string getNewAccountId();
 
    std::string addAccount(const std::map<std::string, std::string>& details,
                           const std::string& accountId = {});
 
    void removeAccount(const std::string& accountID, bool flush = false);
 
    void removeAccounts();
 
    void setAudioPlugin(const std::string& audioPlugin);
 
    void setAudioDevice(int index, AudioDeviceType streamType);
 
    void startAudio();
 
    std::vector<std::string> getAudioOutputDeviceList();
 
    std::vector<std::string> getAudioInputDeviceList();
 
    std::vector<std::string> getCurrentAudioDevicesIndex();
 
    int getAudioInputDeviceIndex(const std::string& name);
    int getAudioOutputDeviceIndex(const std::string& name);
 
    std::string getCurrentAudioOutputPlugin() const;
 
    std::string getNoiseSuppressState() const;
 
    void setNoiseSuppressState(const std::string& state);
 
    bool isAGCEnabled() const;
    void setAGCState(bool enabled);
 
    bool getIsAlwaysRecording() const;
 
    void setIsAlwaysRecording(bool isAlwaysRec);
 
    bool toggleRecordingCall(const std::string& accountId, const std::string& id);
 
    bool startRecordedFilePlayback(const std::string&);
 
    void recordingPlaybackSeek(const double value);
 
    void stopRecordedFilePlayback();
 
    void setHistoryLimit(int days);
 
    int getHistoryLimit() const;
 
    void setRingingTimeout(int timeout);
 
    int getRingingTimeout() const;
 
    std::string getAudioManager() const;
 
    bool setAudioManager(const std::string& api);
 
    AudioFormat hardwareAudioFormatChanged(AudioFormat format);
 
    AudioFormat audioFormatUsed(AudioFormat format);
 
    void ringback();
 
    void playRingtone(const std::string& accountID);
 
    void congestion();
 
    void playDtmf(char code);
 
    void callBusy(Call& call);
 
    void callFailure(Call& call);
 
    std::shared_ptr<AudioLoop> getTelephoneTone();
 
    std::shared_ptr<AudioLoop> getTelephoneFile();
 
    bool incomingCallsWaiting();
 
    std::shared_ptr<Call> getCurrentCall() const;
 
    const std::string& getCurrentCallId() const;
 
    bool isCurrentCall(const Call& call) const;
 
    std::vector<std::string_view> loadAccountOrder() const;
 
    int loadAccountMap(const YAML::Node& node);
 
    std::shared_ptr<Call> getCallFromCallID(const std::string& callID) const;
 
    RingBufferPool& getRingBufferPool();
 
    bool hasCurrentCall() const;
 
    template<class T = Account>
    inline std::shared_ptr<T> getAccount(std::string_view accountId) const
    {
        return accountFactory.getAccount<T>(accountId);
    }
 
    template<class T = Account>
    std::vector<std::shared_ptr<T>> getAllAccounts() const
    {
        const auto& account_order = loadAccountOrder();
        const auto& all_accounts = accountFactory.getAllAccounts<T>();
        std::vector<std::shared_ptr<T>> accountList;
        accountList.reserve(all_accounts.size());
        for (const auto& id : account_order) {
            if (auto acc = accountFactory.getAccount<T>(id))
                accountList.emplace_back(std::move(acc));
        }
        for (auto& account : all_accounts) {
            if (std::find(accountList.begin(), accountList.end(), account) == accountList.end())
                accountList.emplace_back(std::move(account));
        }
        return accountList;
    }
 
    template<class T = Account>
    std::size_t accountCount() const
    {
        return accountFactory.accountCount<T>();
    }
 
    template<class T>
    inline std::shared_ptr<T> findAccount(const std::function<bool(const std::shared_ptr<T>&)>& pred)
    {
        for (const auto& account : getAllAccounts<T>()) {
            if (pred(account))
                return account;
        }
        return {};
    }
 
    // only used by test framework
    bool hasAccount(const std::string& accountID);
 
    void registerAccounts();
 
    void registerAccount(const std::string& accountID, const std::string& convId = {});
 
    void unregisterAccounts();
 
    std::shared_ptr<Call> newOutgoingCall(std::string_view toUrl,
                                          const std::string& accountId,
                                          const std::vector<libjami::MediaMap>& mediaList);
 
    CallFactory callFactory;
 
    const std::shared_ptr<dhtnet::IceTransportFactory>& getIceTransportFactory();
 
    std::shared_ptr<asio::io_context> ioContext() const;
    std::shared_ptr<dhtnet::upnp::UPnPContext> upnpContext() const;
 
    ScheduledExecutor& scheduler();
    std::shared_ptr<Task> scheduleTask(std::function<void()>&& task,
                                       std::chrono::steady_clock::time_point when,
                                       const char* filename = CURRENT_FILENAME(),
                                       uint32_t linum = CURRENT_LINE());
 
    std::shared_ptr<Task> scheduleTaskIn(std::function<void()>&& task,
                                         std::chrono::steady_clock::duration timeout,
                                         const char* filename = CURRENT_FILENAME(),
                                         uint32_t linum = CURRENT_LINE());
 
    std::map<std::string, std::string> getNearbyPeers(const std::string& accountID);
 
#ifdef ENABLE_VIDEO
    std::shared_ptr<video::SinkClient> createSinkClient(const std::string& id = "",
                                                        bool mixer = false);
 
    void createSinkClients(
        const std::string& callId,
        const ConfInfo& infos,
        const std::vector<std::shared_ptr<video::VideoFrameActiveWriter>>& videoStreams,
        std::map<std::string, std::shared_ptr<video::SinkClient>>& sinksMap,
        const std::string& accountId = "");
 
    std::shared_ptr<video::SinkClient> getSinkClient(const std::string& id);
 
#endif // ENABLE_VIDEO
    VideoManager* getVideoManager() const;
 
    unsigned dhtLogLevel {0}; // default = disable
    AccountFactory accountFactory;
 
    std::vector<libjami::Message> getLastMessages(const std::string& accountID,
                                                  const uint64_t& base_timestamp);
 
    SIPVoIPLink& sipVoIPLink() const;
#ifdef ENABLE_PLUGIN
    JamiPluginManager& getJamiPluginManager() const;
#endif
    std::shared_ptr<dhtnet::ChannelSocket> gitSocket(std::string_view accountId,
                                                     std::string_view deviceId,
                                                     std::string_view conversationId);
 
    void setDefaultModerator(const std::string& accountID, const std::string& peerURI, bool state);
    std::vector<std::string> getDefaultModerators(const std::string& accountID);
    void enableLocalModerators(const std::string& accountID, bool state);
    bool isLocalModeratorsEnabled(const std::string& accountID);
    void setAllModerators(const std::string& accountID, bool allModerators);
    bool isAllModerators(const std::string& accountID);
 
    void insertGitTransport(git_smart_subtransport* tr, std::unique_ptr<P2PSubTransport>&& sub);
    void eraseGitTransport(git_smart_subtransport* tr);
 
    dhtnet::tls::CertificateStore& certStore(const std::string& accountId) const;
 
private:
    Manager();
    ~Manager();
    friend class AudioDeviceGuard;
 
    // Data members
    struct ManagerPimpl;
    std::unique_ptr<ManagerPimpl> pimpl_;
};
 
class AudioDeviceGuard
{
public:
    AudioDeviceGuard(Manager& manager, AudioDeviceType type);
    ~AudioDeviceGuard();
 
private:
    Manager& manager_;
    const AudioDeviceType type_;
};
 
// Helper to install a callback to be called once by the main event loop
template<typename Callback>
static void
runOnMainThread(Callback&& cb)
{
    Manager::instance().scheduler().run([cb = std::forward<Callback>(cb)]() mutable { cb(); });
}
 
} // namespace jami