context.hpp

//
//  context.hpp
//  skyway
//
//  Created by sandabu on 2021/11/08.
//  Copyright © 2021 NTT Communications. All rights reserved.
//
 
#ifndef SKYWAY_CORE_CONTEXT_HPP_
#define SKYWAY_CORE_CONTEXT_HPP_
 
#include "skyway/core/config.hpp"
#include "skyway/core/context_options.hpp"
#include "skyway/core/interface/remote_member_plugin.hpp"
#include "skyway/global/error.hpp"
#include "skyway/global/interface/logger.hpp"
#include "skyway/network/interface/http_client.hpp"
#include "skyway/network/interface/websocket_client.hpp"
#include "skyway/platform/interface/platform_info_delegator.hpp"
#include "skyway/rtc_api/interface/client.hpp"
#include "skyway/token/interface/auth_token_manager.hpp"
 
namespace skyway {
namespace core {
namespace channel {
// forward declaration for testing
class CoreChannelTest;
 
}  // namespace channel
}  // namespace core
}  // namespace skyway
 
namespace skyway {
namespace core {
 
using RemoteMemberPluginInterface     = interface::RemoteMemberPlugin;
using AuthTokenManagerInterface       = token::interface::AuthTokenManager;
using RtcApiClientInterface           = rtc_api::interface::Client;
using HttpClientInterface             = network::interface::HttpClient;
using WebSocketClientFactoryInterface = network::interface::WebSocketClientFactory;
using PlatformInfoDelegatorInterface  = platform::interface::PlatformInfoDelegator;
using LoggerInterface                 = global::interface::Logger;
using SkyWayError                     = global::Error;
 
class Context {
public:
    class EventListener {
    public:
        virtual ~EventListener() = default;
 
        virtual void OnReconnectStart() = 0;
 
        virtual void OnReconnectSuccess() = 0;
 
        virtual void OnFatalError(const SkyWayError& error) = 0;
    };
    static bool Setup(const std::string& token,
                      std::unique_ptr<HttpClientInterface> http,
                      std::unique_ptr<WebSocketClientFactoryInterface> ws_factory,
                      std::unique_ptr<PlatformInfoDelegatorInterface> platform_info,
                      std::unique_ptr<LoggerInterface> logger,
                      EventListener* listener,
                      const ContextOptions& options);
 
    static bool UpdateAuthToken(const std::string& token);
 
    static void _UpdateRtcConfig(ContextOptions::RtcConfig rtc_config);
 
    static void RegisterPlugin(std::unique_ptr<RemoteMemberPluginInterface> plugin);
 
    static void Dispose();
 
    static AuthTokenManagerInterface* AuthTokenManager();
 
    static RtcApiClientInterface* RtcApi();
 
    static ContextOptions Options();
 
    static std::vector<RemoteMemberPluginInterface*> GetRemoteMemberPlugins();
 
    static RemoteMemberPluginInterface* FindRemoteMemberPluginBySubtype(const std::string& subtype);
 
    static void OnReconnectStart();
 
    static void OnReconnectSuccess();
 
    static void OnFatalError(const SkyWayError& error);
private:
    static EventListener* listener_;
    static bool is_setup_;
    static std::mutex setup_mtx_;
    static std::unique_ptr<RtcApiClientInterface> rtc_api_;
    static std::unique_ptr<AuthTokenManagerInterface> token_manager_;
    static ContextOptions options_;
    static std::vector<std::unique_ptr<RemoteMemberPluginInterface>> plugins_;
 
public:
    friend class CoreContextTest;
    friend class channel::CoreChannelTest;
};
 
}  // namespace core
}  // namespace skyway
 
#endif /* SKYWAY_CORE_CONTEXT_HPP_ */