StreamClient.h

#ifndef OPENTERA_WEBRTC_NATIVE_CLIENT_STREAM_CLIENT_H
#define OPENTERA_WEBRTC_NATIVE_CLIENT_STREAM_CLIENT_H
 
#include <OpenteraWebrtcNativeClient/Sources/AudioSource.h>
#include <OpenteraWebrtcNativeClient/Sources/VideoSource.h>
#include <OpenteraWebrtcNativeClient/Handlers/StreamPeerConnectionHandler.h>
 
#include <OpenteraWebrtcNativeClient/WebrtcClient.h>
 
#include <memory>
 
namespace opentera
{
    class StreamClient : public WebrtcClient
    {
        std::shared_ptr<VideoSource> m_videoSource;
        std::shared_ptr<AudioSource> m_audioSource;
 
        bool m_hasOnMixedAudioFrameReceivedCallback;
        std::function<void(const Client&)> m_onAddRemoteStream;
        std::function<void(const Client&)> m_onRemoveRemoteStream;
        VideoFrameReceivedCallback m_onVideoFrameReceived;
        EncodedVideoFrameReceivedCallback m_onEncodedVideoFrameReceived;
        AudioFrameReceivedCallback m_onAudioFrameReceived;
 
        bool m_isLocalAudioMuted;
        bool m_isRemoteAudioMuted;
        bool m_isLocalVideoMuted;
 
    public:
        StreamClient(
            SignalingServerConfiguration signalingServerConfiguration,
            WebrtcConfiguration webrtcConfiguration,
            VideoStreamConfiguration videoStreamConfiguration);
        StreamClient(
            SignalingServerConfiguration signalingServerConfiguration,
            WebrtcConfiguration webrtcConfiguration,
            VideoStreamConfiguration videoStreamConfiguration,
            std::shared_ptr<VideoSource> videoSource);
        StreamClient(
            SignalingServerConfiguration signalingServerConfiguration,
            WebrtcConfiguration webrtcConfiguration,
            VideoStreamConfiguration videoStreamConfiguration,
            std::shared_ptr<AudioSource> audioSource);
        StreamClient(
            SignalingServerConfiguration signalingServerConfiguration,
            WebrtcConfiguration webrtcConfiguration,
            VideoStreamConfiguration videoStreamConfiguration,
            std::shared_ptr<VideoSource> videoSource,
            std::shared_ptr<AudioSource> audioSource);
        ~StreamClient() override;
 
        DECLARE_NOT_COPYABLE(StreamClient);
        DECLARE_NOT_MOVABLE(StreamClient);
 
        bool isLocalAudioMuted();
        void muteLocalAudio();
        void unmuteLocalAudio();
        void setLocalAudioMuted(bool muted);
 
        bool isRemoteAudioMuted();
        void muteRemoteAudio();
        void unmuteRemoteAudio();
        void setRemoteAudioMuted(bool muted);
 
        bool isLocalVideoMuted();
        void muteLocalVideo();
        void unmuteLocalVideo();
        void setLocalVideoMuted(bool muted);
 
        void setOnAddRemoteStream(const std::function<void(const Client&)>& callback);
        void setOnRemoveRemoteStream(const std::function<void(const Client&)>& callback);
        void setOnVideoFrameReceived(const VideoFrameReceivedCallback& callback);
        void setOnEncodedVideoFrameReceived(const EncodedVideoFrameReceivedCallback& callback);
        void setOnAudioFrameReceived(const AudioFrameReceivedCallback& callback);
        void setOnMixedAudioFrameReceived(const AudioSinkCallback& callback);
 
    protected:
        std::unique_ptr<PeerConnectionHandler>
            createPeerConnectionHandler(const std::string& id, const Client& peerClient, bool isCaller) override;
    };
 
    inline bool StreamClient::isLocalAudioMuted()
    {
        return callSync(getInternalClientThread(), [this]() { return m_isLocalAudioMuted; });
    }
 
 
    inline void StreamClient::muteLocalAudio() { setLocalAudioMuted(true); }
 
    inline void StreamClient::unmuteLocalAudio() { setLocalAudioMuted(false); }
 
    inline bool StreamClient::isRemoteAudioMuted()
    {
        return callSync(getInternalClientThread(), [this]() { return m_isRemoteAudioMuted; });
    }
 
    inline void StreamClient::muteRemoteAudio() { setRemoteAudioMuted(true); }
 
    inline void StreamClient::unmuteRemoteAudio() { setRemoteAudioMuted(false); }
 
    inline bool StreamClient::isLocalVideoMuted()
    {
        return callSync(getInternalClientThread(), [this]() { return m_isLocalVideoMuted; });
    }
 
    inline void StreamClient::muteLocalVideo() { setLocalVideoMuted(true); }
 
    inline void StreamClient::unmuteLocalVideo() { setLocalVideoMuted(false); }
 
    inline void StreamClient::setOnAddRemoteStream(const std::function<void(const Client&)>& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onAddRemoteStream = callback; });
    }
 
    inline void StreamClient::setOnRemoveRemoteStream(const std::function<void(const Client&)>& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onRemoveRemoteStream = callback; });
    }
 
    inline void StreamClient::setOnVideoFrameReceived(const VideoFrameReceivedCallback& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onVideoFrameReceived = callback; });
    }
 
    inline void StreamClient::setOnEncodedVideoFrameReceived(const EncodedVideoFrameReceivedCallback& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onEncodedVideoFrameReceived = callback; });
    }
 
    inline void StreamClient::setOnAudioFrameReceived(const AudioFrameReceivedCallback& callback)
    {
        callSync(getInternalClientThread(), [this, &callback]() { m_onAudioFrameReceived = callback; });
    }
 
    inline void StreamClient::setOnMixedAudioFrameReceived(const AudioSinkCallback& callback)
    {
        bool hasOnMixedAudioFrameReceivedCallback(callback);
        callSync(
            getInternalClientThread(),
            [this, hasOnMixedAudioFrameReceivedCallback]()
            { m_hasOnMixedAudioFrameReceivedCallback = hasOnMixedAudioFrameReceivedCallback; });
 
        m_audioDeviceModule->setOnMixedAudioFrameReceived(callback);
    }
}
 
#endif