DataChannelClient.h

#ifndef OPENTERA_WEBRTC_NATIVE_CLIENT_DATA_CHANNEL_CLIENT_H
#define OPENTERA_WEBRTC_NATIVE_CLIENT_DATA_CHANNEL_CLIENT_H
 
#include <OpenteraWebrtcNativeClient/WebrtcClient.h>
#include <OpenteraWebrtcNativeClient/Utils/ClassMacro.h>
#include <OpenteraWebrtcNativeClient/Configurations/DataChannelConfiguration.h>
 
#include <api/data_channel_interface.h>
 
namespace opentera
{
    class DataChannelClient : public WebrtcClient
    {
        DataChannelConfiguration m_dataChannelConfiguration;
 
        std::function<void(const Client&)> m_onDataChannelOpened;
        std::function<void(const Client&)> m_onDataChannelClosed;
        std::function<void(const Client&, const std::string&)> m_onDataChannelError;
        std::function<void(const Client&, const uint8_t*, std::size_t)> m_onDataChannelMessageBinary;
        std::function<void(const Client&, const std::string&)> m_onDataChannelMessageString;
 
    public:
        DataChannelClient(
            SignalingServerConfiguration signalingServerConfiguration,
            WebrtcConfiguration webrtcConfiguration,
            DataChannelConfiguration dataChannelConfiguration);
        ~DataChannelClient() override = default;
 
        DECLARE_NOT_COPYABLE(DataChannelClient);
        DECLARE_NOT_MOVABLE(DataChannelClient);
 
        bool sendTo(const uint8_t* data, std::size_t size, const std::vector<std::string>& ids);
        bool sendTo(const std::string& message, const std::vector<std::string>& ids);
        bool sendToAll(const uint8_t* data, std::size_t size);
        bool sendToAll(const std::string& message);
 
        void setOnDataChannelOpened(const std::function<void(const Client&)>& callback);
        void setOnDataChannelClosed(const std::function<void(const Client&)>& callback);
        void setOnDataChannelError(const std::function<void(const Client&, const std::string&)>& callback);
        void setOnDataChannelMessageBinary(
            const std::function<void(const Client&, const uint8_t*, std::size_t)>& callback);
        void setOnDataChannelMessageString(const std::function<void(const Client&, const std::string&)>& callback);
 
    protected:
        bool sendTo(const webrtc::DataBuffer& buffer, const std::vector<std::string>& ids);
        bool sendToAll(const webrtc::DataBuffer& buffer);
 
        std::unique_ptr<PeerConnectionHandler>
            createPeerConnectionHandler(const std::string& id, const Client& peerClient, bool isCaller) override;
    };
 
    inline bool DataChannelClient::sendTo(const uint8_t* data, size_t size, const std::vector<std::string>& ids)
    {
        return sendTo(webrtc::DataBuffer(rtc::CopyOnWriteBuffer(data, size), true), ids);
    }
 
    inline bool DataChannelClient::sendTo(const std::string& message, const std::vector<std::string>& ids)
    {
        return sendTo(webrtc::DataBuffer(message), ids);
    }
 
    inline bool DataChannelClient::sendToAll(const uint8_t* data, size_t size)
    {
        return sendToAll(webrtc::DataBuffer(rtc::CopyOnWriteBuffer(data, size), true));
    }
 
    inline bool DataChannelClient::sendToAll(const std::string& message)
    {
        return sendToAll(webrtc::DataBuffer(message));
    }
 
    inline void DataChannelClient::setOnDataChannelOpened(const std::function<void(const Client&)>& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onDataChannelOpened = callback; });
    }
 
    inline void DataChannelClient::setOnDataChannelClosed(const std::function<void(const Client&)>& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onDataChannelClosed = callback; });
    }
 
    inline void
        DataChannelClient::setOnDataChannelError(const std::function<void(const Client&, const std::string&)>& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onDataChannelError = callback; });
    }
 
    inline void DataChannelClient::setOnDataChannelMessageBinary(
        const std::function<void(const Client&, const uint8_t*, std::size_t)>& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onDataChannelMessageBinary = callback; });
    }
 
    inline void DataChannelClient::setOnDataChannelMessageString(
        const std::function<void(const Client&, const std::string&)>& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onDataChannelMessageString = callback; });
    }
}
 
#endif