room.hpp

#ifndef SKYWAY_ROOM_INTERFACE_ROOM_HPP
#define SKYWAY_ROOM_INTERFACE_ROOM_HPP
 
#include <functional>
 
#include <skyway/core/interface/channel.hpp>
 
#include "skyway/room/interface/local_room_member.hpp"
#include "skyway/room/interface/remote_room_member.hpp"
#include "skyway/room/interface/room_domain_cache_manager.hpp"
#include "skyway/room/interface/room_domain_factory.hpp"
#include "skyway/room/interface/room_publication.hpp"
#include "skyway/room/interface/room_subscription.hpp"
#include "skyway/room/types.hpp"
 
namespace skyway {
namespace room {
namespace interface {
 
struct RoomInitOptions {
    std::optional<std::string> name;
    std::optional<std::string> metadata;
    model::Channel::Init ToCore() {
        model::Channel::Init core;
        core.name     = name;
        core.metadata = metadata;
        return core;
    }
};
 
struct RoomQuery {
    std::optional<std::string> id;
    std::optional<std::string> name;
    model::Channel::Query ToCore() {
        model::Channel::Query core;
        core.id   = id;
        core.name = name;
        return core;
    }
};
 
struct RoomMemberInitOptions {
    std::optional<std::string> name;
    std::optional<std::string> metadata;
    std::optional<int> keepalive_interval_sec;
    std::optional<int> keepalive_interval_gap_sec;
    model::Member::Init ToCore() {
        model::Member::Init core;
        core.name                       = name;
        core.metadata                   = metadata;
        core.keepalive_interval_sec     = keepalive_interval_sec;
        core.keepalive_interval_gap_sec = keepalive_interval_gap_sec;
        return core;
    }
};
 
class Room {
public:
    class EventListener {
    public:
        virtual ~EventListener() = default;
        virtual void OnClosed() {}
 
        virtual void OnMetadataUpdated(const std::string& metadata) {}
 
        virtual void OnMemberListChanged() {}
 
        virtual void OnMemberJoined(std::shared_ptr<RoomMember> member) {}
 
        virtual void OnMemberLeft(std::shared_ptr<RoomMember> member) {}
 
        virtual void OnMemberMetadataUpdated(std::shared_ptr<RoomMember> member,
                                             const std::string& metadata) {}
 
        virtual void OnPublicationMetadataUpdated(std::shared_ptr<RoomPublication> publication,
                                                  const std::string& metadata) {}
 
        virtual void OnPublicationListChanged() {}
 
        virtual void OnStreamPublished(std::shared_ptr<RoomPublication> publication) {}
 
        virtual void OnStreamUnpublished(std::shared_ptr<RoomPublication> publication) {}
 
        virtual void OnPublicationEnabled(std::shared_ptr<RoomPublication> publication) {}
 
        virtual void OnPublicationDisabled(std::shared_ptr<RoomPublication> publication) {}
 
        virtual void OnSubscriptionListChanged() {}
 
        virtual void OnPublicationSubscribed(std::shared_ptr<RoomSubscription> subscription) {}
 
        virtual void OnPublicationUnsubscribed(std::shared_ptr<RoomSubscription> subscription) {}
 
        virtual void OnSubscriptionEnabled(std::shared_ptr<RoomSubscription> subscription) {}
 
        virtual void OnSubscriptionDisabled(std::shared_ptr<RoomSubscription> subscription) {}
    };
    virtual ~Room() = default;
    virtual std::string Id() = 0;
    virtual std::optional<std::string> Name() = 0;
    virtual RoomType Type() = 0;
    virtual std::optional<std::string> Metadata() = 0;
    virtual RoomState State() = 0;
    virtual std::vector<std::shared_ptr<RoomPublication>> Publications() = 0;
    virtual std::vector<std::shared_ptr<RoomSubscription>> Subscriptions() = 0;
    virtual std::vector<std::shared_ptr<RoomMember>> Members() = 0;
 
    virtual void AddEventListener(EventListener* listener) = 0;
    virtual void RemoveEventListener(EventListener* listener) = 0;
    virtual bool UpdateMetadata(const std::string& metadata) = 0;
    virtual bool Leave(RoomMember* member) = 0;
    virtual bool Close() = 0;
    virtual void Dispose() = 0;
 
    virtual std::shared_ptr<interface::RoomDomainCacheManager<interface::RoomPublication>>
    GetRoomPublicationCacheManager() = 0;
    virtual std::shared_ptr<interface::RoomDomainCacheManager<interface::RoomSubscription>>
    GetRoomSubscriptionCacheManager() = 0;
    virtual std::shared_ptr<interface::RoomDomainCacheManager<interface::LocalRoomMember>>
    GetLocalRoomMemberCacheManager() = 0;
    virtual std::shared_ptr<interface::RoomDomainCacheManager<interface::RemoteRoomMember>>
    GetRemoteRoomMemberCacheManager()                                         = 0;
    virtual void RunWithRoomEventListenerLock(std::function<void()> function) = 0;
};
 
class RoomFactory {
public:
    virtual ~RoomFactory() = default;
    virtual std::shared_ptr<Room> Create(
        RoomInitOptions options, std::unique_ptr<interface::RoomDomainFactory> domain_factory) = 0;
    virtual std::shared_ptr<Room> Find(
        RoomQuery query, std::unique_ptr<interface::RoomDomainFactory> domain_factory) = 0;
    virtual std::shared_ptr<Room> FindOrCreate(
        RoomInitOptions options, std::unique_ptr<interface::RoomDomainFactory> domain_factory) = 0;
};
 
}  // namespace interface
}  // namespace room
}  // namespace skyway
 
#endif /* SKYWAY_ROOM_INTERFACE_ROOM_HPP */