local_room_member.hpp

//
// © NTT DOCOMO BUSINESS, Inc. All Rights Reserved.
//
 
#ifndef SKYWAY_ROOM_INTERFACE_LOCAL_ROOM_MEMBER_HPP
#define SKYWAY_ROOM_INTERFACE_LOCAL_ROOM_MEMBER_HPP
 
#include <skyway/core/interface/local_person.hpp>
#include <skyway/model/domain.hpp>
 
#include "skyway/room/interface/room_member.hpp"
 
namespace skyway {
namespace room {
namespace interface {
 
class LocalRoomMember : public virtual RoomMember {
public:
    class EventListener : public RoomMember::EventListener {
    public:
        virtual ~EventListener() = default;
        virtual void OnStreamPublished(std::shared_ptr<RoomPublication> publication) {}
 
        virtual void OnStreamUnpublished(std::shared_ptr<RoomPublication> publication) {}
 
        virtual void OnPublicationSubscribed(std::shared_ptr<RoomSubscription> subscription) {}
 
        virtual void OnPublicationUnsubscribed(std::shared_ptr<RoomSubscription> subscription) {}
    };
 
    struct PublicationOptions {
        std::optional<std::string> metadata;
        std::vector<model::Codec> codec_capabilities;
        std::vector<model::Encoding> encodings;
        bool is_enabled = true;
        int max_subscribers = 10;
        model::PublicationType type = model::PublicationType::kP2P;
        core::interface::LocalPerson::PublicationOptions ToCore() {
            core::interface::LocalPerson::PublicationOptions core_opt;
            core_opt.metadata           = metadata;
            core_opt.codec_capabilities = codec_capabilities;
            core_opt.encodings          = encodings;
            core_opt.is_enabled         = is_enabled;
            core_opt.type               = type;
            return core_opt;
        }
    };
 
    struct SubscriptionOptions {
        std::optional<std::string> preferred_encoding_id;
        core::interface::LocalPerson::SubscriptionOptions ToCore() {
            core::interface::LocalPerson::SubscriptionOptions core_opt;
            core_opt.preferred_encoding_id = preferred_encoding_id;
            return core_opt;
        }
    };
 
    virtual ~LocalRoomMember() = default;
    virtual void AddEventListener(EventListener* listener) = 0;
    virtual void RemoveEventListener(EventListener* listener) = 0;
    virtual std::shared_ptr<RoomPublication> Publish(std::shared_ptr<core::interface::LocalStream>,
                                                     PublicationOptions options) = 0;
    virtual std::shared_ptr<RoomSubscription> Subscribe(const std::string& publication_id,
                                                        SubscriptionOptions options) = 0;
    virtual bool Unpublish(const std::string& publication_id) = 0;
    virtual bool Unsubscribe(const std::string& subscription_id) = 0;
};
 
}  // namespace interface
}  // namespace room
}  // namespace skyway
 
#endif /* SKYWAY_ROOM_INTERFACE_LOCAL_ROOM_MEMBER_HPP */