WebRTCDataChannels.h

//
//  WebRTCDataChannels.h
//  libraries/networking/src/webrtc
//
//  Created by David Rowe on 21 May 2021.
//  Copyright 2021 Vircadia contributors.
//
 
#ifndef overte_WebRTCDataChannels_h
#define overte_WebRTCDataChannels_h
 
#include <shared/WebRTC.h>
 
#if defined(WEBRTC_DATA_CHANNELS)
 
 
#include <QObject>
#include <QHash>
 
#undef emit  // Avoid conflict between Qt signals/slots and the WebRTC library's.
#include <api/peer_connection_interface.h>
#define emit
 
#include "../NodeType.h"
#include "../SockAddr.h"
 
class WebRTCDataChannels;
class WDCConnection;
 
 
 
class WDCSetSessionDescriptionObserver : public webrtc::SetSessionDescriptionObserver {
public:
 
    void OnSuccess() override;
 
    void OnFailure(webrtc::RTCError error) override;
};
 
 
class WDCCreateSessionDescriptionObserver : public webrtc::CreateSessionDescriptionObserver {
public:
 
    WDCCreateSessionDescriptionObserver(WDCConnection* parent);
 
    void OnSuccess(webrtc::SessionDescriptionInterface* desc) override;
 
    void OnFailure(webrtc::RTCError error) override;
 
private:
    WDCConnection* _parent;
};
 
 
class WDCPeerConnectionObserver : public webrtc::PeerConnectionObserver {
public:
 
    WDCPeerConnectionObserver(WDCConnection* parent);
 
    void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState newState) override;
 
    void OnRenegotiationNeeded() override;
 
    void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState newState) override;
 
    void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
 
    virtual void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState newState) override;
 
    virtual void OnStandardizedIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState newState) override;
 
    void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> dataChannel) override;
 
    void OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState newState) override;
 
private:
    WDCConnection* _parent;
};
 
 
class WDCDataChannelObserver : public webrtc::DataChannelObserver {
public:
 
    WDCDataChannelObserver(WDCConnection* parent);
 
    void OnStateChange() override;
 
    void OnMessage(const webrtc::DataBuffer& buffer) override;
 
private:
    WDCConnection* _parent;
};
 
 
class WDCConnection {
 
public:
 
    WDCConnection(WebRTCDataChannels* parent, const QString& dataChannelID);
 
    QString getDataChannelID() const { return _dataChannelID; }
 
 
    void setRemoteDescription(QJsonObject& description);
 
    void createAnswer();
 
    void sendAnswer(webrtc::SessionDescriptionInterface* description);
    
    void setLocalDescription(webrtc::SessionDescriptionInterface* description);
    
    void addIceCandidate(QJsonObject& data);
 
    void sendIceCandidate(const webrtc::IceCandidateInterface* candidate);
 
    void onPeerConnectionStateChanged(webrtc::PeerConnectionInterface::PeerConnectionState state);
 
    void onDataChannelOpened(rtc::scoped_refptr<webrtc::DataChannelInterface> dataChannel);
 
    void onDataChannelStateChanged();
 
 
    void onDataChannelMessageReceived(const webrtc::DataBuffer& buffer);
 
    qint64 getBufferedAmount() const;
 
 
    bool sendDataMessage(const webrtc::DataBuffer& buffer);
 
    void closePeerConnection();
    
private:
    WebRTCDataChannels* _parent;
    QString _dataChannelID;
 
    rtc::scoped_refptr<WDCSetSessionDescriptionObserver> _setSessionDescriptionObserver { nullptr };
    rtc::scoped_refptr<WDCCreateSessionDescriptionObserver> _createSessionDescriptionObserver { nullptr };
 
    std::shared_ptr<WDCDataChannelObserver> _dataChannelObserver { nullptr };
    rtc::scoped_refptr<webrtc::DataChannelInterface> _dataChannel { nullptr };
 
    std::shared_ptr<WDCPeerConnectionObserver> _peerConnectionObserver { nullptr };
    rtc::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection { nullptr };
};
 
 
class WebRTCDataChannels : public QObject {
    Q_OBJECT
 
public:
 
    WebRTCDataChannels(QObject* parent);
 
    ~WebRTCDataChannels();
 
    NodeType_t getNodeType() {
        return _nodeType;
    }
 
    void reset();
    
    void onDataChannelOpened(WDCConnection* connection, const QString& dataChannelID);
 
    void sendSignalingMessage(const QJsonObject& message);
 
    void emitDataMessage(const QString& dataChannelID, const QByteArray& byteArray);
 
    bool sendDataMessage(const SockAddr& destination, const QByteArray& message);
 
    qint64 getBufferedAmount(const SockAddr& address) const;
 
    rtc::scoped_refptr<webrtc::PeerConnectionInterface> createPeerConnection(
        const std::shared_ptr<WDCPeerConnectionObserver> peerConnectionObserver);
 
    void closePeerConnection(WDCConnection* connection);
 
public slots:
 
    void onSignalingMessage(const QJsonObject& message);
 
    void closePeerConnectionNow(WDCConnection* connection);
 
signals:
 
    void signalingMessage(const QJsonObject& message);
 
    void dataMessage(const SockAddr& address, const QByteArray& byteArray);
 
    void closePeerConnectionSoon(WDCConnection* connection);
 
private:
 
    QObject* _parent;
 
    NodeType_t _nodeType { NodeType::Unassigned };
 
    std::unique_ptr<rtc::Thread> _rtcNetworkThread { nullptr };
    std::unique_ptr<rtc::Thread> _rtcWorkerThread { nullptr };
    std::unique_ptr<rtc::Thread> _rtcSignalingThread { nullptr };
 
    rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> _peerConnectionFactory { nullptr };
 
    QHash<QString, WDCConnection*> _connectionsByID;  // <client data channel ID, WDCConnection>
    // The client's WebSocket IP and port is used as the data channel ID to uniquely identify each.
    // The WebSocket IP address and port is formatted as "n.n.n.n:n", the same as used in WebRTCSignalingServer.
};
 
 
 
#endif // WEBRTC_DATA_CHANNELS
 
#endif // overte_WebRTCDataChannels_h