local_person.hpp

//
//  local_person.hpp
//  skyway
//
//  Created by Naoto Takahashi on 2023/08/04.
//  Copyright © 2023 NTT Communications. All rights reserved.
//
 
#ifndef SKYWAY_CORE_INTERFACE_LOCAL_PERSON_HPP_
#define SKYWAY_CORE_INTERFACE_LOCAL_PERSON_HPP_
 
#include "skyway/analytics/interface/analytics_client.hpp"
#include "skyway/core/interface/chunk_messenger.hpp"
#include "skyway/core/interface/local_stream.hpp"
#include "skyway/core/interface/publication.hpp"
#include "skyway/core/interface/remote_member.hpp"
 
namespace skyway {
namespace core {
namespace interface {
 
class LocalPerson : public Member {
public:
    class EventListener : public Member::EventListener {
    public:
        virtual void OnStreamPublished(Publication* publication) {}
        virtual void OnStreamUnpublished(Publication* publication) {}
        virtual void OnPublicationSubscribed(Subscription* subscription) {}
        virtual void OnPublicationUnsubscribed(Subscription* subscription) {}
    };
    struct PublicationOptions {
        boost::optional<std::string> metadata;
        std::vector<model::Codec> codec_capabilities;
        std::vector<model::Encoding> encodings;
        bool is_enabled;
 
        PublicationOptions(bool is_enabled = true) : is_enabled(is_enabled) {}
    };
    struct SubscriptionOptions {
        bool is_enabled;
        boost::optional<std::string> preferred_encoding_id;
        SubscriptionOptions(bool is_enabled = true) : is_enabled(is_enabled) {}
    };
    virtual ~LocalPerson() = default;
 
    virtual ChunkMessenger* Messenger() const = 0;
 
    virtual analytics::interface::AnalyticsClient* AnalyticsClient() const = 0;
 
    virtual Publication* Publish(std::shared_ptr<LocalStream> stream,
                                 PublicationOptions options) = 0;
 
    virtual Subscription* Subscribe(const std::string& publication_id,
                                    const SubscriptionOptions& options) = 0;
 
    virtual bool Unpublish(const std::string& publication_id) const = 0;
 
    virtual bool Unsubscribe(const std::string& subscription_id) const = 0;
 
    // These event functions are invoked by local person's action after receiving success message
    // from RTC-API server
    virtual void OnPublished(Publication* publication)                               = 0;
    virtual void OnUnpublished(Publication* publication)                             = 0;
    virtual void OnSubscribed(Subscription* subscription, RemoteMember* publisher)   = 0;
    virtual void OnUnsubscribed(Subscription* subscription, RemoteMember* publisher) = 0;
 
    // These event functions are invoked by remote member
    virtual void OnPublicationSubscribedByRemoteMember(Subscription* subscription,
                                                       RemoteMember* subscriber)   = 0;
    virtual void OnPublicationUnsubscribedByRemoteMember(Subscription* subscription,
                                                         RemoteMember* subscriber) = 0;
 
    virtual void Dispose() = 0;
 
protected:
    LocalPerson(Channel* channel, const model::Member& dto);
};
 
}  // namespace interface
}  // namespace core
}  // namespace skyway
 
#endif /* SKYWAY_CORE_INTERFACE_LOCAL_PERSON_HPP_ */