context.hpp

#ifndef SKYWAY_CONTEXT_HPP_
#define SKYWAY_CONTEXT_HPP_
 
#include <mutex>
 
#include <skyway/core/context.hpp>
#include <skyway/core/interface/remote_member_plugin.hpp>
#include <skyway/global/error.hpp>
#include <skyway/global/logger.hpp>
#include <skyway/network/interface/http_client.hpp>
#include <skyway/network/interface/websocket_client.hpp>
#include "skyway/media/codec/video_codec.hpp"
#include "skyway/media/device_manager.hpp"
 
namespace skyway {
namespace media {
namespace rtp {
 
class PassthroughVideoEncoderFactoryTest;
 
}  // namespace rtp
}  // namespace media
 
class Context {
public:
    static const unsigned int kVersionMajor = 4;
    static const unsigned int kVersionMinor = 1;
    static const unsigned int kVersionPatch = 1;
 
    class EventListener {
    public:
        virtual ~EventListener() = default;
 
        virtual void OnReconnectStart() = 0;
 
        virtual void OnReconnectSuccess() = 0;
 
        virtual void OnFatalError(const global::Error& error) = 0;
    };
 
    class AuthTokenListener {
    public:
        virtual ~AuthTokenListener() = default;
 
        virtual void OnTokenRefreshingNeeded() {}
 
        virtual void OnTokenExpired() {}
    };
 
    struct SkyWayOptions {
 
        struct RtcApi {
            std::optional<std::string> domain;
            std::optional<bool> secure;
        };
 
        struct IceParams {
            std::optional<std::string> domain;
            std::optional<int> version;
            std::optional<bool> secure;
            webrtc::PeerConnectionInterface::IceServers custom_ice_servers;
        };
 
        struct Signaling {
            std::optional<std::string> domain;
            std::optional<bool> secure;
        };
 
        struct Analytics {
            std::optional<std::string> domain;
            std::optional<bool> secure;
        };
 
        struct RtcConfig {
            std::optional<int> timeout;
            std::optional<domain::TurnPolicy> policy;
        };
 
 
        struct Token {
            [[deprecated]] std::optional<int> remind_time_sec;
            std::optional<int> update_remind_sec;
            AuthTokenListener* listener = nullptr;
        };
 
        struct Rtp {
            struct Input {
                struct Video {
                    bool enabled;
                    std::shared_ptr<media::codec::VideoCodec> codec;
                    Video() : enabled(false), codec(nullptr) {}
                };
                Video video;
            };
            Input input;
        };
        domain::LogLevel log_level = domain::LogLevel::kInfo;
 
        RtcApi rtc_api;
        IceParams ice_params;
        Signaling signaling;
        Analytics analytics;
        RtcConfig rtc_config;
        Token token;
 
        bool enable_webrtc_log = false;
 
        skyway::media::AudioBackendType audio_backend =
            skyway::media::AudioBackendType::kPulseAudio;
 
        skyway::media::AudioProcessingOptions audio_processing;
 
        Rtp rtp;
 
        struct SFU {
            std::optional<std::string> domain;
            std::optional<int> version;
            std::optional<bool> secure;
        };
        SFU sfu;
    };
 
    static bool Setup(const std::string& token,
                      EventListener* listener,
                      const SkyWayOptions& options);
 
    static bool SetupForDev(const std::string& app_id,
                            const std::string& secret_key,
                            EventListener* listener,
                            const SkyWayOptions& options);
 
    static void Dispose();
 
    static bool UpdateAuthToken(const std::string& token);
 
    static std::string GetVersionString();
 
    static std::shared_ptr<media::codec::VideoCodec> GetRtpVideoInputCodecWithValidate();
 
private:
    class CoreEventListenerAdapter : public core::Context::EventListener {
    public:
        CoreEventListenerAdapter();
        void SetListener(Context::EventListener* listener);
        void OnReconnectStart() override;
        void OnReconnectSuccess() override;
        void OnFatalError(const global::Error& error) override;
 
    private:
        Context::EventListener* listener_;
    };
 
    class CoreAuthTokenListenerAdapter : public token::interface::AuthTokenManager::Listener {
    public:
        CoreAuthTokenListenerAdapter();
        void SetListener(Context::AuthTokenListener* listener);
        void OnTokenRefreshingNeeded() override;
        void OnTokenExpired() override;
 
    private:
        Context::AuthTokenListener* listener_;
    };
 
    static core::TurnPolicy ConvertToCoreTurnPolicy(domain::TurnPolicy policy);
    static core::ContextOptions ConvertToCoreContextOptions(const SkyWayOptions& options);
 
    inline static SkyWayOptions::Rtp rtp_;
    static std::mutex core_event_listener_mutex_;
    static CoreEventListenerAdapter core_event_listener_adapter_;
    static std::mutex core_auth_token_listener_mutex_;
    static CoreAuthTokenListenerAdapter core_auth_token_listener_adapter_;
 
public:
    friend class media::rtp::PassthroughVideoEncoderFactoryTest;
};
}  // namespace skyway
 
#endif /* SKYWAY_CONTEXT_HPP_ */