StreamApi.hpp

/*
PrivMX Endpoint.
Copyright © 2024 Simplito sp. z o.o.
 
This file is part of the PrivMX Platform (https://privmx.dev).
This software is Licensed under the PrivMX Free License.
 
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#ifndef _PRIVMXLIB_ENDPOINT_STREAM_STREAMAPI_HPP_
#define _PRIVMXLIB_ENDPOINT_STREAM_STREAMAPI_HPP_
 
#include "privmx/endpoint/stream/webrtc/OnTrackInterface.hpp"
#include "privmx/endpoint/stream/webrtc/Types.hpp"
#include <memory>
#include <optional>
#include <privmx/endpoint/core/Connection.hpp>
#include <privmx/endpoint/core/Types.hpp>
#include <privmx/endpoint/event/EventApi.hpp>
#include <string>
#include <vector>
 
namespace privmx {
namespace endpoint {
namespace stream {
 
class StreamApiImpl;

class StreamApi {
public:
    static StreamApi create(core::Connection& connection, event::EventApi& eventApi);

    StreamApi() = default;

    std::string createStreamRoom(
        const std::string& contextId,
        const std::vector<core::UserWithPubKey>& users,
        const std::vector<core::UserWithPubKey>& managers,
        const core::Buffer& publicMeta,
        const core::Buffer& privateMeta,
        const std::optional<core::ContainerPolicyWithoutItem>& policies,
        const std::optional<int64_t>& emptyRoomTtl = std::nullopt
    );

    void updateStreamRoom(
        const std::string& streamRoomId,
        const std::vector<core::UserWithPubKey>& users,
        const std::vector<core::UserWithPubKey>& managers,
        const core::Buffer& publicMeta,
        const core::Buffer& privateMeta,
        const int64_t version,
        const bool force,
        const bool forceGenerateNewKey,
        const std::optional<core::ContainerPolicyWithoutItem>& policies
    );

    core::PagingList<StreamRoom> listStreamRooms(const std::string& contextId, const core::PagingQuery& query);

    StreamRoom getStreamRoom(const std::string& streamRoomId);

    void deleteStreamRoom(const std::string& streamRoomId);

    std::vector<std::string> subscribeFor(const std::vector<std::string>& subscriptionQueries);

    void unsubscribeFrom(const std::vector<std::string>& subscriptionIds);

    std::string buildSubscriptionQuery(
        EventType eventType,
        EventSelectorType selectorType,
        const std::string& selectorId
    );

    std::vector<StreamInfo> listStreams(const std::string& streamRoomId);

    std::vector<StreamSubscriber> listStreamRoomParticipants(const std::string& streamRoomId);

    void joinStreamRoom(const std::string& streamRoomId); // required before createStream and openStream

    void leaveStreamRoom(const std::string& streamRoomId);

    StreamHandle createStream(const std::string& streamRoomId);

    std::vector<AudioDevice> getAudioDevices();

    std::vector<VideoDevice> getVideoDevices();

    std::vector<DesktopDevice> getDesktopDevices(DesktopType desktopType);

    MediaTrack addTrack(
        const StreamHandle& streamHandle,
        const MediaDevice& track,
        const MediaTrackConstrains& mediaTrackConstrains
    );

    void removeTrack(const StreamHandle& streamHandle, const MediaDevice& track);

    StreamPublishResult publishStream(const StreamHandle& streamHandle);

    StreamPublishResult updateStream(const StreamHandle& streamHandle);

    void removeStream(const StreamHandle& streamHandle);

    SubscriberStreamHandle createSubscriberStream(
        const std::string& streamRoomId,
        const std::vector<StreamSubscription>& subscriptions
    );

    void updateSubscriberStream(
        const SubscriberStreamHandle& subscriptionHandle,
        const std::vector<StreamSubscription>& subscriptionsToAdd,
        const std::vector<StreamSubscription>& subscriptionsToRemove
    );

    void removeSubscriberStream(const SubscriberStreamHandle& subscriptionHandle);

    void dropBrokenFrames(const std::string& streamRoomId, bool enable);

    void addRemoteStreamListener(
        const std::string& streamRoomId,
        std::optional<int64_t> streamId,
        std::shared_ptr<OnTrackInterface> onTrack
    );

    void sendData(const StreamHandle& streamHandle, core::Buffer data);

    std::shared_ptr<StreamApiImpl> getImpl() const { return _impl; }
 
private:
    void validateEndpoint();
    StreamApi(const std::shared_ptr<StreamApiImpl>& impl);
    std::shared_ptr<StreamApiImpl> _impl;
};
 
} // namespace stream
} // namespace endpoint
} // namespace privmx
 
#endif // _PRIVMXLIB_ENDPOINT_STREAM_STREAMAPI_HPP_