channel.hpp

//
//  channel.hpp
//  skyway
//
//  Created by sandabu on 2022/01/13.
//  Copyright © 2022 NTT Communications. All rights reserved.
//
 
#ifndef SKYWAY_CORE_INTERFACE_CHANNEL_HPP_
#define SKYWAY_CORE_INTERFACE_CHANNEL_HPP_
 
#include "skyway/core/interface/local_person.hpp"
#include "skyway/core/interface/publication.hpp"
#include "skyway/core/interface/remote_member.hpp"
#include "skyway/core/interface/subscription.hpp"
#include "skyway/model/domain.hpp"
#include "skyway/rtc_api/channel_state.hpp"
#include "skyway/signaling/interface/signaling_client.hpp"
 
namespace skyway {
namespace core {
namespace interface {
 
enum class ChannelState { kOpened, kClosed };
 
class Channel {
public:
    class EventListener {
    public:
        virtual void OnClosed() {}
 
        virtual void OnMetadataUpdated(const std::string& metadata) {}
 
        virtual void OnMemberListChanged() {}
 
        virtual void OnMemberJoined(Member* member) {}
 
        virtual void OnMemberLeft(Member* member) {}
 
        virtual void OnMemberMetadataUpdated(Member* member, const std::string& metadata) {}
 
        virtual void OnPublicationMetadataUpdated(Publication* publication,
                                                  const std::string& metadata) {}
 
        virtual void OnPublicationListChanged() {}
 
        virtual void OnStreamPublished(Publication* publication) {}
 
        virtual void OnStreamUnpublished(Publication* publication) {}
 
        virtual void OnPublicationEnabled(Publication* publication) {}
 
        virtual void OnPublicationDisabled(Publication* publication) {}
 
        virtual void OnSubscriptionListChanged() {}
 
        virtual void OnPublicationSubscribed(Subscription* subscription) {}
 
        virtual void OnPublicationUnsubscribed(Subscription* subscription) {}
 
        virtual void OnSubscriptionEnabled(Subscription* subscription) {}
 
        virtual void OnSubscriptionDisabled(Subscription* subscription) {}
    };
 
    class InternalEventListener {
    public:
        virtual void OnPublicationSubscribed(Subscription* subscription) {}
 
        virtual void OnPublicationUnsubscribed(Subscription* subscription) {}
    };
 
    virtual ~Channel() = default;
 
    virtual void AddEventListener(EventListener* listener) = 0;
 
    virtual void RemoveEventListener(EventListener* listener) = 0;
 
    virtual std::string Id() const = 0;
 
    virtual boost::optional<std::string> Name() const = 0;
 
    virtual boost::optional<std::string> Metadata() const = 0;
 
    virtual interface::LocalPerson* LocalPerson() = 0;
 
    virtual std::vector<RemoteMember*> Bots(bool active_only = true) = 0;
 
    virtual std::vector<Member*> Members(bool active_only = true) = 0;
 
    virtual std::vector<Publication*> Publications(bool active_only = true) = 0;
 
    virtual std::vector<Subscription*> Subscriptions(bool active_only = true) = 0;
 
    virtual ChannelState State() const = 0;
 
    virtual interface::LocalPerson* Join(const model::Member::Init& init) = 0;
 
    virtual bool Leave(Member* member) = 0;
 
    virtual bool Close() = 0;
 
    virtual void Dispose(bool remove_myself_if_needed) = 0;
 
    virtual bool UpdateMetadata(const std::string& metadata) = 0;
 
    virtual Member* FindMember(const std::string& member_id, bool active_only = true) = 0;
 
    virtual RemoteMember* FindRemoteMember(const std::string& member_id,
                                           bool active_only = true) = 0;
 
    virtual Publication* FindPublication(const std::string& publication_id,
                                         bool active_only = true) = 0;
 
    virtual Subscription* FindSubscription(const std::string& subscription_id,
                                           bool active_only = true) = 0;
 
    virtual std::vector<Subscription*> GetSubscriptionsByPublicationId(
        const std::string& publication_id, bool active_only = true) = 0;
 
    virtual std::vector<Subscription*> GetSubscriptionsBySubscriberId(
        const std::string& subscriber_id, bool active_only = true) = 0;
 
    virtual std::vector<Publication*> GetPublicationsByPublisherId(const std::string& publisher_id,
                                                                   bool active_only = true) = 0;
 
    virtual boost::optional<model::Member> GetMemberDto(const std::string& member_id) const = 0;
    virtual boost::optional<model::Publication> GetPublicationDto(
        const std::string& publication_id) const = 0;
    virtual boost::optional<model::Subscription> GetSubscriptionDto(
        const std::string& subscription_id) const = 0;
 
    virtual void AddInternalEventListener(InternalEventListener*)    = 0;
    virtual void RemoveInternalEventListener(InternalEventListener*) = 0;
};
 
}  // namespace interface
}  // namespace core
}  // namespace skyway
 
#endif /* SKYWAY_CORE_INTERFACE_CHANNEL_HPP_ */