Bdtyktl

In my main.js I have a websocket handle new connections which opens a new BrowserWindow loading my rendering.js which uses desktopCapturer to handle the stream and build up the webrtc connection.

I need to use a turn server but am unsure of howto define this as attempts thus far have failed. The app will be built with docker and opening 10k udp ports or bridging onto host network is not feasable.

I have tried define the turn server like

myPeerConnection = new RTCPeerConnection({

  iceServers: [

    {

      urls: ["turns:turnserver.example.org", "turn:turnserver.example.org"],

      username: "webrtc",

      credential: "turnpassword"

    }

  ]

});

renderer.js

const {desktopCapturer} = require('electron')

const EventEmitter = require('events');

const {ipcRenderer} = require('electron')

const fs = require('fs')

var socketId = null;

var windowId = null;

var otherConfig;

var windowStreamer;

socketId = require('electron').remote.getCurrentWindow().getTitle();

windowId = socketId;



class WindowStreamer extends EventEmitter {

    constructor(windowId) {

        super();    

        this.offerOptions = {

            offerToReceiveAudio: 1,

            offerToReceiveVideo: 1

        }

        this.peer = new RTCPeerConnection(null); // This is where I think I should define the turn server??? but it did not work.

        this.sdp = null;

        this.icecandidates = ;

        let that = this;

        desktopCapturer.getSources({types: ['window', 'screen']}, (error, sources) => {

            if (error) {

                throw error

            } else {

                for (let i = 0; i < sources.length; ++i) {

                    if (sources[i].name === windowId) {

                        navigator.mediaDevices.getUserMedia({

                            audio: false,                  

                            video: {

                                mandatory: {

                                    chromeMediaSource: 'desktop',

                                    chromeMediaSourceId: sources[i].id,

                                    minWidth: 800,

                                    maxWidth: 1921,

                                    minHeight: 600,

                                    maxHeight: 1081

                                }

                            }

                        })

                        .then(stream => that.handleStream(stream))

                        .catch(e => ipcRenderer.send('async',JSON.stringify("Error while trying to access window " + windowId + " video source. " + e)))

                    }

                }

            }

        })

    }

    handleStream(stream) {

        this.peer.addStream(stream);

        this.peer.onicecandidate = e => this.icecandidates.push(e.candidate);

        let that = this;

        this.peer.createOffer(this.offerOptions).then(desc=> {

            that.sdp = desc;

            that.peer.setLocalDescription(desc);

            setTimeout(that.monitorGatheringState, 100);

        }, e => ipcRenderer.send('async',JSON.stringify("Error while creating RTC offer: " + e)));

    }

    setClientConfig (config) {

        config = JSON.parse(config);

        let that = this;

        this.peer.setRemoteDescription(config.sdp);

        config.icecandidates.forEach(candidate => {

            if(candidate != null || candidate != undefined) {

                let rtcicecandidate = new RTCIceCandidate(candidate);

                that.peer.addIceCandidate(rtcicecandidate)

                .then(s => {}, e => ipcRenderer.send('async', JSON.stringify('Error whileadding RTCIceCandidate ' + e)))



            }

        })

        let message = { 

            socketId: socketId

        }

    }

    monitorGatheringState() {

        if(windowStreamer.peer.iceGatheringState == "complete") {

            windowStreamer.emit("ice-gathering-completed", windowStreamer.sdp, windowStreamer.icecandidates);

            let message = { 

                socketId: socketId,

                config: {

                    sdp: windowStreamer.sdp, 

                    icecandidates: windowStreamer.icecandidates

                }

            }

        } else {

            setTimeout(windowStreamer.monitorGatheringState, 100);

        }

    }

}



ipcRenderer.on('client-webrtc-config', (event, data) => {

    otherConfig = data;

    windowStreamer.setClientConfig(otherConfig);

})



windowStreamer = new WindowStreamer(windowId);

How should I define my TURN server?