|
|
/* eslint-disable */
|
|
|
|
|
|
/**
|
|
|
*
|
|
|
* @returns
|
|
|
*/
|
|
|
|
|
|
"use strict";
|
|
|
|
|
|
var adapter = require("./adapter");
|
|
|
// eslint-disable-next-line no-unused-vars
|
|
|
var WebRTCAdaptor = function(initialValues) {
|
|
|
|
|
|
class PeerStats {
|
|
|
|
|
|
constructor(streamId) {
|
|
|
this.streamId = streamId;
|
|
|
this.totalBytesReceivedCount = 0;
|
|
|
this.totalBytesSent = 0;
|
|
|
this.packetsLost = 0;
|
|
|
this.fractionLost = 0;
|
|
|
this.startTime = 0;
|
|
|
this.lastBytesReceived = 0;
|
|
|
this.lastBytesSent = 0;
|
|
|
this.currentTimestamp = 0;
|
|
|
this.janusScreen = null;
|
|
|
this.lastTime = 0;
|
|
|
this.timerId = 0;
|
|
|
this.firstByteSentCount = 0;
|
|
|
this.firstBytesReceivedCount = 0;
|
|
|
}
|
|
|
|
|
|
//kbits/sec
|
|
|
get averageOutgoingBitrate() {
|
|
|
return Math.floor(8 * (this.totalBytesSentCount - this.firstByteSentCount) / (this.currentTimestamp - this.startTime));
|
|
|
}
|
|
|
|
|
|
//kbits/sec
|
|
|
get averageIncomingBitrate() {
|
|
|
return Math.floor(8 * (this.totalBytesReceivedCount - this.firstBytesReceivedCount) / (this.currentTimestamp - this.startTime));
|
|
|
}
|
|
|
|
|
|
//kbits/sec
|
|
|
get currentOutgoingBitrate() {
|
|
|
return Math.floor(8 * (this.totalBytesSentCount - this.lastBytesSent) / (this.currentTimestamp - this.lastTime));
|
|
|
}
|
|
|
|
|
|
//kbits/sec
|
|
|
get currentIncomingBitrate() {
|
|
|
return Math.floor(8 * (this.totalBytesReceivedCount - this.lastBytesReceived) / (this.currentTimestamp - this.lastTime));
|
|
|
}
|
|
|
|
|
|
set currentTime(timestamp) {
|
|
|
this.lastTime = this.currentTimestamp;
|
|
|
this.currentTimestamp = timestamp;
|
|
|
if (this.startTime == 0) {
|
|
|
this.startTime = timestamp - 1; // do not have zero division error
|
|
|
}
|
|
|
}
|
|
|
|
|
|
set totalBytesReceived(bytesReceived) {
|
|
|
this.lastBytesReceived = this.totalBytesReceivedCount;
|
|
|
this.totalBytesReceivedCount = bytesReceived;
|
|
|
if (this.firstBytesReceivedCount == 0) {
|
|
|
this.firstBytesReceivedCount = bytesReceived;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
set totalBytesSent(bytesSent) {
|
|
|
this.lastBytesSent = this.totalBytesSentCount;
|
|
|
this.totalBytesSentCount = bytesSent;
|
|
|
if (this.firstByteSentCount == 0) {
|
|
|
this.firstByteSentCount = bytesSent;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
var thiz = this;
|
|
|
thiz.peerconnection_config = null;
|
|
|
thiz.sdp_constraints = null;
|
|
|
thiz.remotePeerConnection = new Array();
|
|
|
thiz.remotePeerConnectionStats = new Array();
|
|
|
thiz.remoteDescriptionSet = new Array();
|
|
|
thiz.iceCandidateList = new Array();
|
|
|
thiz.webSocketAdaptor = null;
|
|
|
thiz.roomName = null;
|
|
|
thiz.videoTrackSender = null;
|
|
|
thiz.audioTrackSender = null;
|
|
|
thiz.playStreamId = new Array();
|
|
|
thiz.micGainNode = null;
|
|
|
thiz.localStream = null;
|
|
|
thiz.bandwidth = 512; //default bandwidth kbps
|
|
|
|
|
|
thiz.isPlayMode = false;
|
|
|
thiz.debug = false;
|
|
|
|
|
|
/**
|
|
|
* The cam_location below is effective when camera and screen is send at the same time.
|
|
|
* possible values are top and bottom. It's on right all the time
|
|
|
*/
|
|
|
thiz.camera_location = "top"
|
|
|
|
|
|
/**
|
|
|
* The cam_margin below is effective when camera and screen is send at the same time.
|
|
|
* This is the margin value in px from the edges
|
|
|
*/
|
|
|
thiz.camera_margin = 15;
|
|
|
|
|
|
/**
|
|
|
* Thiz camera_percent is how large the camera view appear on the screen. It's %15 by default.
|
|
|
*/
|
|
|
thiz.camera_percent = 100;
|
|
|
|
|
|
for (var key in initialValues) {
|
|
|
if (initialValues.hasOwnProperty(key)) {
|
|
|
this[key] = initialValues[key];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
thiz.localVideo = document.getElementById(thiz.localVideoId);
|
|
|
thiz.remoteVideo = document.getElementById(thiz.remoteVideoId);
|
|
|
|
|
|
if (!("WebSocket" in window)) {
|
|
|
console.log("WebSocket not supported.");
|
|
|
thiz.callbackError("WebSocketNotSupported");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (typeof navigator.mediaDevices == "undefined" && thiz.isPlayMode == false) {
|
|
|
console.log("Cannot open camera and mic because of unsecure context. Please Install SSL(https)");
|
|
|
thiz.callbackError("UnsecureContext");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Get user media
|
|
|
*/
|
|
|
this.getUserMedia = function (mediaConstraints, audioConstraint) {
|
|
|
navigator.mediaDevices.getUserMedia(mediaConstraints)
|
|
|
.then(function (stream) {
|
|
|
|
|
|
//this trick, getting audio and video separately, make us add or remove tracks on the fly
|
|
|
var audioTrack = stream.getAudioTracks();
|
|
|
if (audioTrack.length > 0) {
|
|
|
stream.removeTrack(audioTrack[0]);
|
|
|
}
|
|
|
|
|
|
//add callback if desktop is sharing
|
|
|
if (mediaConstraints.video != "undefined"
|
|
|
// eslint-disable-next-line no-mixed-spaces-and-tabs
|
|
|
&& typeof mediaConstraints.video.mandatory != "undefined"
|
|
|
// eslint-disable-next-line no-mixed-spaces-and-tabs
|
|
|
&& typeof mediaConstraints.video.mandatory.chromeMediaSource != "undefined"
|
|
|
// eslint-disable-next-line no-mixed-spaces-and-tabs
|
|
|
&& mediaConstraints.video.mandatory.chromeMediaSource == "desktop") {
|
|
|
|
|
|
stream.getVideoTracks()[0].onended = function (event) {
|
|
|
thiz.callback("screen_share_stopped");
|
|
|
}
|
|
|
}
|
|
|
if (thiz.janusScreen) {
|
|
|
thiz.gotStream(thiz.janusScreen);
|
|
|
} else if (audioConstraint != "undefined" && audioConstraint != false) {
|
|
|
var media_audio_constraint = {audio: audioConstraint};
|
|
|
navigator.mediaDevices.getUserMedia(media_audio_constraint)
|
|
|
.then(function (audioStream) {
|
|
|
|
|
|
|
|
|
if (thiz.mediaConstraints != "undefined" && thiz.mediaConstraints.video == "screen+camera") {
|
|
|
navigator.mediaDevices.getUserMedia({video: true, audio: false})
|
|
|
.then(function (cameraStream) {
|
|
|
//create a canvas element
|
|
|
var canvas = document.createElement("canvas");
|
|
|
var canvasContext = canvas.getContext("2d");
|
|
|
|
|
|
//create video element for screen
|
|
|
//var screenVideo = document.getElementById('sourceVideo');
|
|
|
var screenVideo = document.createElement('video');
|
|
|
//TODO: check audio track
|
|
|
screenVideo.srcObject = stream;
|
|
|
screenVideo.play();
|
|
|
|
|
|
|
|
|
//create video element for camera
|
|
|
var cameraVideo = document.createElement('video');
|
|
|
//TODO: check audio track
|
|
|
cameraVideo.srcObject = cameraStream;
|
|
|
cameraVideo.play();
|
|
|
|
|
|
|
|
|
var canvasStream = canvas.captureStream(15);
|
|
|
canvasStream.addTrack(audioStream.getAudioTracks()[0]);
|
|
|
//call gotStream
|
|
|
thiz.gotStream(canvasStream);
|
|
|
|
|
|
//update the canvas
|
|
|
setInterval(function () {
|
|
|
|
|
|
//draw screen to canvas
|
|
|
canvas.width = screenVideo.videoWidth;
|
|
|
canvas.height = screenVideo.videoHeight;
|
|
|
canvasContext.drawImage(screenVideo, 0, 0, canvas.width, canvas.height);
|
|
|
|
|
|
var cameraWidth = screenVideo.videoWidth * (thiz.camera_percent / 100);
|
|
|
var cameraHeight = (cameraVideo.videoHeight / cameraVideo.videoWidth) * cameraWidth
|
|
|
|
|
|
var positionX = (canvas.width - cameraWidth) - thiz.camera_margin;
|
|
|
var positionY;
|
|
|
|
|
|
if (thiz.camera_location == "top") {
|
|
|
positionY = thiz.camera_margin;
|
|
|
} else { //if not top, make it bottom
|
|
|
//draw camera on right bottom corner
|
|
|
positionY = (canvas.height - cameraHeight) - thiz.camera_margin;
|
|
|
}
|
|
|
|
|
|
canvasContext.drawImage(cameraVideo, positionX, positionY, cameraWidth, cameraHeight);
|
|
|
|
|
|
|
|
|
}, 66);
|
|
|
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
thiz.callbackError(error.name, error.message);
|
|
|
});
|
|
|
} else {
|
|
|
stream.addTrack(audioStream.getAudioTracks()[0]);
|
|
|
thiz.gotStream(stream);
|
|
|
}
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
thiz.callbackError(error.name, error.message);
|
|
|
});
|
|
|
} else {
|
|
|
stream.addTrack(audioStream.getAudioTracks()[0]);
|
|
|
thiz.gotStream(stream);
|
|
|
}
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
thiz.callbackError(error.name, error.message);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
this.openScreen = function (audioConstraint, openCamera) {
|
|
|
var callback = function (message) {
|
|
|
if (message.data == "rtcmulticonnection-extension-loaded") {
|
|
|
console.debug("rtcmulticonnection-extension-loaded parameter is received");
|
|
|
window.postMessage("get-sourceId", "*");
|
|
|
} else if (message.data == "PermissionDeniedError") {
|
|
|
console.debug("Permission denied error");
|
|
|
thiz.callbackError("screen_share_permission_denied");
|
|
|
} else if (message.data && message.data.sourceId) {
|
|
|
var mediaConstraints = {
|
|
|
audio: false,
|
|
|
video: {
|
|
|
mandatory: {
|
|
|
chromeMediaSource: 'desktop',
|
|
|
chromeMediaSourceId: message.data.sourceId,
|
|
|
},
|
|
|
optional: []
|
|
|
}
|
|
|
};
|
|
|
|
|
|
thiz.getUserMedia(mediaConstraints, audioConstraint);
|
|
|
|
|
|
//remove event listener
|
|
|
window.removeEventListener("message", callback);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
window.addEventListener("message", callback, false);
|
|
|
|
|
|
window.postMessage("are-you-there", "*");
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Open media stream, it may be screen, camera or audio
|
|
|
*/
|
|
|
this.openStream = function (mediaConstraints) {
|
|
|
|
|
|
thiz.mediaConstraints = mediaConstraints;
|
|
|
var audioConstraint = false;
|
|
|
if (typeof mediaConstraints.audio != "undefined" && mediaConstraints.audio != false) {
|
|
|
audioConstraint = mediaConstraints.audio;
|
|
|
}
|
|
|
|
|
|
if (typeof mediaConstraints.video != "undefined") {
|
|
|
|
|
|
if (mediaConstraints.video == "screen+camera" || mediaConstraints.video == "screen") {
|
|
|
this.openScreen(audioConstraint);
|
|
|
} else {
|
|
|
thiz.getUserMedia(mediaConstraints, audioConstraint);
|
|
|
}
|
|
|
} else {
|
|
|
console.error("MediaConstraint video is not defined");
|
|
|
thiz.callbackError("media_constraint_video_not_defined");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Closes stream, if you want to stop peer connection, call stop(streamId)
|
|
|
*/
|
|
|
this.closeStream = function () {
|
|
|
|
|
|
thiz.localStream.getVideoTracks().forEach(function (track) {
|
|
|
track.onended = null;
|
|
|
track.stop();
|
|
|
});
|
|
|
|
|
|
thiz.localStream.getAudioTracks().forEach(function (track) {
|
|
|
track.onended = null;
|
|
|
track.stop();
|
|
|
});
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Checks chrome screen share extension is avaiable
|
|
|
* if exists it call callback with "screen_share_extension_available"
|
|
|
*/
|
|
|
this.checkExtension = function () {
|
|
|
var callback = function (message) {
|
|
|
|
|
|
if (message.data == "rtcmulticonnection-extension-loaded") {
|
|
|
thiz.callback("screen_share_extension_available");
|
|
|
window.removeEventListener("message", callback);
|
|
|
}
|
|
|
|
|
|
};
|
|
|
//add event listener for desktop capture
|
|
|
window.addEventListener("message", callback, false);
|
|
|
|
|
|
window.postMessage("are-you-there", "*");
|
|
|
|
|
|
};
|
|
|
|
|
|
/*
|
|
|
* Call check extension. Below function is called when this class is created
|
|
|
*/
|
|
|
thiz.checkExtension();
|
|
|
|
|
|
/*
|
|
|
* Below lines are executed as well when this class is created
|
|
|
*/
|
|
|
if (!this.isPlayMode && typeof thiz.mediaConstraints != "undefined" && this.localStream == null) {
|
|
|
if (typeof thiz.mediaConstraints.video != "undefined" && thiz.mediaConstraints.video != false) {
|
|
|
// if it is not play mode and media constraint is defined, try to get user media
|
|
|
if (thiz.mediaConstraints.audio.mandatory) {
|
|
|
//this case captures mic and video(audio(screen audio) + video(screen)) and then provide mute/unmute mic with
|
|
|
//enableMicInMixedAudio
|
|
|
navigator.mediaDevices.getUserMedia({audio: true, video: false}).then(function (micStream) {
|
|
|
navigator.mediaDevices.getUserMedia(thiz.mediaConstraints)
|
|
|
.then(function (stream) {
|
|
|
//console.debug("audio stream track count: " + audioStream.getAudioTracks().length);
|
|
|
|
|
|
var audioContext = new AudioContext();
|
|
|
var desktopSoundGainNode = audioContext.createGain();
|
|
|
|
|
|
desktopSoundGainNode.gain.value = 1;
|
|
|
|
|
|
var audioDestionation = audioContext.createMediaStreamDestination();
|
|
|
var audioSource = audioContext.createMediaStreamSource(stream);
|
|
|
|
|
|
audioSource.connect(desktopSoundGainNode);
|
|
|
|
|
|
thiz.micGainNode = audioContext.createGain();
|
|
|
thiz.micGainNode.gain.value = 1;
|
|
|
var audioSource2 = audioContext.createMediaStreamSource(micStream);
|
|
|
audioSource2.connect(thiz.micGainNode);
|
|
|
|
|
|
desktopSoundGainNode.connect(audioDestionation);
|
|
|
thiz.micGainNode.connect(audioDestionation);
|
|
|
|
|
|
stream.removeTrack(stream.getAudioTracks()[0]);
|
|
|
audioDestionation.stream.getAudioTracks().forEach(function (track) {
|
|
|
stream.addTrack(track);
|
|
|
});
|
|
|
|
|
|
console.debug("Running gotStream");
|
|
|
thiz.gotStream(stream);
|
|
|
|
|
|
}).catch(function (error) {
|
|
|
thiz.callbackError(error.name, error.message);
|
|
|
});
|
|
|
}).catch(function (error) {
|
|
|
thiz.callbackError(error.name, error.message);
|
|
|
});
|
|
|
} else {
|
|
|
//most of the times, this statement runs
|
|
|
thiz.openStream(thiz.mediaConstraints, thiz.mode);
|
|
|
}
|
|
|
} else {
|
|
|
// get only audio
|
|
|
var media_audio_constraint = {audio: thiz.mediaConstraints.audio};
|
|
|
navigator.mediaDevices.getUserMedia(media_audio_constraint)
|
|
|
.then(function (stream) {
|
|
|
thiz.gotStream(stream);
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
thiz.callbackError(error.name, error.message);
|
|
|
});
|
|
|
}
|
|
|
} else {
|
|
|
|
|
|
//just playing, it does not open any stream
|
|
|
if (thiz.webSocketAdaptor == null || thiz.webSocketAdaptor.isConnected() == false) {
|
|
|
thiz.webSocketAdaptor = new WebSocketAdaptor();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.enableMicInMixedAudio = function (enable) {
|
|
|
if (thiz.micGainNode != null) {
|
|
|
if (enable) {
|
|
|
thiz.micGainNode.gain.value = 1;
|
|
|
} else {
|
|
|
thiz.micGainNode.gain.value = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.publish = function (streamId, token) {
|
|
|
var jsCmd = {
|
|
|
command: "publish",
|
|
|
streamId: streamId,
|
|
|
token: token,
|
|
|
video: { width: 1280, height: 720 },
|
|
|
audio: true,
|
|
|
};
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
|
|
|
|
|
|
this.joinRoom = function (roomName, streamId) {
|
|
|
thiz.roomName = roomName;
|
|
|
|
|
|
var jsCmd = {
|
|
|
command: "joinRoom",
|
|
|
room: roomName,
|
|
|
streamId: streamId,
|
|
|
}
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
|
|
|
}
|
|
|
|
|
|
this.play = function (streamId, token, roomId) {
|
|
|
thiz.playStreamId.push(streamId);
|
|
|
var jsCmd =
|
|
|
{
|
|
|
command: "play",
|
|
|
streamId: streamId,
|
|
|
token: token,
|
|
|
room: roomId,
|
|
|
}
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
|
|
|
this.stop = function (streamId) {
|
|
|
thiz.closePeerConnection(streamId);
|
|
|
|
|
|
var jsCmd = {
|
|
|
command: "stop",
|
|
|
streamId: streamId,
|
|
|
};
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
|
|
|
this.join = function (streamId) {
|
|
|
var jsCmd = {
|
|
|
command: "join",
|
|
|
streamId: streamId,
|
|
|
};
|
|
|
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
|
|
|
this.leaveFromRoom = function (roomName) {
|
|
|
thiz.roomName = roomName;
|
|
|
var jsCmd = {
|
|
|
command: "leaveFromRoom",
|
|
|
room: roomName,
|
|
|
};
|
|
|
console.log("leave request is sent for " + roomName);
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
|
|
|
this.leave = function (streamId) {
|
|
|
|
|
|
var jsCmd = {
|
|
|
command: "leave",
|
|
|
streamId: streamId,
|
|
|
};
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
thiz.closePeerConnection(streamId);
|
|
|
}
|
|
|
|
|
|
this.getStreamInfo = function (streamId) {
|
|
|
var jsCmd = {
|
|
|
command: "getStreamInfo",
|
|
|
streamId: streamId,
|
|
|
};
|
|
|
this.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
|
|
|
this.gotStream = function (stream) {
|
|
|
thiz.localStream = stream;
|
|
|
// thiz.localVideo.srcObject = stream;
|
|
|
if (thiz.webSocketAdaptor == null || thiz.webSocketAdaptor.isConnected() == false) {
|
|
|
thiz.webSocketAdaptor = new WebSocketAdaptor();
|
|
|
}
|
|
|
};
|
|
|
|
|
|
this.switchVideoCapture = function (streamId) {
|
|
|
var mediaConstraints = {
|
|
|
video: true,
|
|
|
audio: true
|
|
|
};
|
|
|
|
|
|
thiz.switchVideoSource(streamId, mediaConstraints, null);
|
|
|
}
|
|
|
|
|
|
this.switchDesktopCapture = function (streamId) {
|
|
|
|
|
|
var screenShareExtensionCallback = function (message) {
|
|
|
|
|
|
if (message.data == "rtcmulticonnection-extension-loaded") {
|
|
|
console.debug("rtcmulticonnection-extension-loaded parameter is received");
|
|
|
window.postMessage("get-sourceId", "*");
|
|
|
} else if (message.data == "PermissionDeniedError") {
|
|
|
console.debug("Permission denied error");
|
|
|
thiz.callbackError("screen_share_permission_denied");
|
|
|
} else if (message.data && message.data.sourceId) {
|
|
|
var mediaConstraints = {
|
|
|
audio: true,
|
|
|
video: {
|
|
|
mandatory: {
|
|
|
chromeMediaSource: 'desktop',
|
|
|
chromeMediaSourceId: message.data.sourceId,
|
|
|
},
|
|
|
optional: []
|
|
|
}
|
|
|
};
|
|
|
|
|
|
thiz.switchVideoSource(streamId, mediaConstraints, function (event) {
|
|
|
thiz.callback("screen_share_stopped");
|
|
|
thiz.switchVideoCapture(streamId);
|
|
|
});
|
|
|
|
|
|
//remove event listener
|
|
|
window.removeEventListener("message", screenShareExtensionCallback);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
//add event listener for desktop capture
|
|
|
window.addEventListener("message", screenShareExtensionCallback, false);
|
|
|
|
|
|
window.postMessage("are-you-there", "*");
|
|
|
}
|
|
|
|
|
|
thiz.arrangeStreams = function (stream, onEndedCallback) {
|
|
|
var videoTrack = thiz.localStream.getVideoTracks()[0];
|
|
|
thiz.localStream.removeTrack(videoTrack);
|
|
|
videoTrack.stop();
|
|
|
thiz.localStream.addTrack(stream.getVideoTracks()[0]);
|
|
|
// thiz.localVideo.srcObject = thiz.localStream;
|
|
|
if (onEndedCallback != null) {
|
|
|
stream.getVideoTracks()[0].onended = function (event) {
|
|
|
onEndedCallback(event);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.switchVideoSource = function (streamId, mediaConstraints, onEndedCallback) {
|
|
|
|
|
|
navigator.mediaDevices.getUserMedia(mediaConstraints)
|
|
|
.then(function (stream) {
|
|
|
|
|
|
if (thiz.remotePeerConnection[streamId] != null) {
|
|
|
var videoTrackSender = thiz.remotePeerConnection[streamId].getSenders().find(function (s) {
|
|
|
return s.track.kind == "video";
|
|
|
});
|
|
|
|
|
|
videoTrackSender.replaceTrack(stream.getVideoTracks()[0]).then(function (result) {
|
|
|
thiz.arrangeStreams(stream, onEndedCallback);
|
|
|
|
|
|
}).catch(function (error) {
|
|
|
console.log(error.name);
|
|
|
});
|
|
|
} else {
|
|
|
thiz.arrangeStreams(stream, onEndedCallback);
|
|
|
}
|
|
|
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
thiz.callbackError(error.name);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
|
|
|
this.onTrack = function (event, streamId) {
|
|
|
console.log("onTrack");
|
|
|
if (thiz.remoteVideo != null) {
|
|
|
//thiz.remoteVideo.srcObject = event.streams[0];
|
|
|
if (thiz.remoteVideo.srcObject !== event.streams[0]) {
|
|
|
thiz.remoteVideo.srcObject = event.streams[0];
|
|
|
console.log('Received remote stream');
|
|
|
}
|
|
|
} else {
|
|
|
var dataObj = {
|
|
|
track: event.streams[0],
|
|
|
streamId: streamId
|
|
|
}
|
|
|
thiz.callback("newStreamAvailable", dataObj);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
this.iceCandidateReceived = function (event, streamId) {
|
|
|
if (event.candidate) {
|
|
|
|
|
|
var jsCmd = {
|
|
|
command: "takeCandidate",
|
|
|
streamId: streamId,
|
|
|
label: event.candidate.sdpMLineIndex,
|
|
|
id: event.candidate.sdpMid,
|
|
|
candidate: event.candidate.candidate
|
|
|
};
|
|
|
|
|
|
if (thiz.debug) {
|
|
|
console.log("sending ice candiate for stream Id " + streamId);
|
|
|
console.log(JSON.stringify(event.candidate));
|
|
|
}
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
this.initPeerConnection = function (streamId) {
|
|
|
if (thiz.remotePeerConnection[streamId] == null) {
|
|
|
var closedStreamId = streamId;
|
|
|
console.log("stream id in init peer connection: " + streamId + " close dstream id: " + closedStreamId);
|
|
|
thiz.remotePeerConnection[streamId] = new RTCPeerConnection(thiz.peerconnection_config);
|
|
|
thiz.remoteDescriptionSet[streamId] = false;
|
|
|
thiz.iceCandidateList[streamId] = new Array();
|
|
|
if (!thiz.playStreamId.includes(streamId)) {
|
|
|
thiz.remotePeerConnection[streamId].addStream(thiz.localStream);
|
|
|
}
|
|
|
thiz.remotePeerConnection[streamId].onicecandidate = function (event) {
|
|
|
thiz.iceCandidateReceived(event, closedStreamId);
|
|
|
}
|
|
|
thiz.remotePeerConnection[streamId].ontrack = function (event) {
|
|
|
thiz.onTrack(event, closedStreamId);
|
|
|
}
|
|
|
|
|
|
if (!thiz.isPlayMode) {
|
|
|
thiz.remotePeerConnection[streamId].oniceconnectionstatechange = function (event) {
|
|
|
|
|
|
if (thiz.remotePeerConnection[streamId].iceConnectionState == "connected") {
|
|
|
|
|
|
thiz.changeBandwidth(thiz.bandwidth, streamId).then(() => {
|
|
|
console.log("Bandwidth is changed to " + thiz.bandwidth);
|
|
|
})
|
|
|
.catch(e => console.error(e));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.closePeerConnection = function (streamId) {
|
|
|
if (thiz.remotePeerConnection[streamId] != null
|
|
|
&& thiz.remotePeerConnection[streamId].signalingState != "closed") {
|
|
|
thiz.remotePeerConnection[streamId].close();
|
|
|
thiz.remotePeerConnection[streamId] = null;
|
|
|
delete thiz.remotePeerConnection[streamId];
|
|
|
var playStreamIndex = thiz.playStreamId.indexOf(streamId);
|
|
|
if (playStreamIndex != -1) {
|
|
|
thiz.playStreamId.splice(playStreamIndex, 1);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if (thiz.remotePeerConnectionStats[streamId] != null) {
|
|
|
clearInterval(thiz.remotePeerConnectionStats[streamId].timerId);
|
|
|
delete thiz.remotePeerConnectionStats[streamId];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.signallingState = function (streamId) {
|
|
|
if (thiz.remotePeerConnection[streamId] != null) {
|
|
|
return thiz.remotePeerConnection[streamId].signalingState;
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
this.iceConnectionState = function (streamId) {
|
|
|
if (thiz.remotePeerConnection[streamId] != null) {
|
|
|
return thiz.remotePeerConnection[streamId].iceConnectionState;
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
this.gotDescription = function (configuration, streamId) {
|
|
|
thiz.remotePeerConnection[streamId]
|
|
|
.setLocalDescription(configuration)
|
|
|
.then(function (responose) {
|
|
|
console.debug("Set local description successfully for stream Id " + streamId);
|
|
|
|
|
|
var jsCmd = {
|
|
|
command: "takeConfiguration",
|
|
|
streamId: streamId,
|
|
|
type: configuration.type,
|
|
|
sdp: configuration.sdp
|
|
|
|
|
|
};
|
|
|
|
|
|
if (thiz.debug) {
|
|
|
console.debug("local sdp: ");
|
|
|
console.debug(configuration.sdp);
|
|
|
}
|
|
|
|
|
|
thiz.webSocketAdaptor.send(JSON.stringify(jsCmd));
|
|
|
|
|
|
}).catch(function (error) {
|
|
|
console.error("Cannot set local description. Error is: " + error);
|
|
|
});
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
this.turnOffLocalCamera = function () {
|
|
|
if (thiz.remotePeerConnection != null) {
|
|
|
|
|
|
var track = thiz.localStream.getVideoTracks()[0];
|
|
|
track.enabled = false;
|
|
|
} else {
|
|
|
this.callbackError("NoActiveConnection");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.turnOnLocalCamera = function () {
|
|
|
if (thiz.remotePeerConnection != null) {
|
|
|
var track = thiz.localStream.getVideoTracks()[0];
|
|
|
track.enabled = true;
|
|
|
} else {
|
|
|
this.callbackError("NoActiveConnection");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.muteLocalMic = function () {
|
|
|
if (thiz.remotePeerConnection != null) {
|
|
|
var track = thiz.localStream.getAudioTracks()[0];
|
|
|
track.enabled = false;
|
|
|
} else {
|
|
|
this.callbackError("NoActiveConnection");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* if there is audio it calls callbackError with "AudioAlreadyActive" parameter
|
|
|
*/
|
|
|
this.unmuteLocalMic = function () {
|
|
|
if (thiz.remotePeerConnection != null) {
|
|
|
var track = thiz.localStream.getAudioTracks()[0];
|
|
|
track.enabled = true;
|
|
|
} else {
|
|
|
this.callbackError("NoActiveConnection");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.takeConfiguration = function (idOfStream, configuration, typeOfConfiguration) {
|
|
|
var streamId = idOfStream
|
|
|
var type = typeOfConfiguration;
|
|
|
var conf = configuration;
|
|
|
|
|
|
thiz.initPeerConnection(streamId);
|
|
|
|
|
|
thiz.remotePeerConnection[streamId].setRemoteDescription(new RTCSessionDescription({
|
|
|
sdp: conf,
|
|
|
type: type
|
|
|
})).then(function (response) {
|
|
|
|
|
|
if (thiz.debug) {
|
|
|
console.debug("set remote description is succesfull with response: " + response + " for stream : "
|
|
|
+ streamId + " and type: " + type);
|
|
|
console.debug(conf);
|
|
|
}
|
|
|
|
|
|
thiz.remoteDescriptionSet[streamId] = true;
|
|
|
var length = thiz.iceCandidateList[streamId].length;
|
|
|
console.debug("Ice candidate list size to be added: " + length);
|
|
|
for (var i = 0; i < length; i++) {
|
|
|
thiz.addIceCandidate(streamId, thiz.iceCandidateList[streamId][i]);
|
|
|
}
|
|
|
thiz.iceCandidateList[streamId] = [];
|
|
|
|
|
|
if (type == "offer") {
|
|
|
//SDP constraints may be different in play mode
|
|
|
console.log("try to create answer for stream id: " + streamId);
|
|
|
|
|
|
thiz.remotePeerConnection[streamId].createAnswer(thiz.sdp_constraints)
|
|
|
.then(function (configuration) {
|
|
|
console.log("created answer for stream id: " + streamId);
|
|
|
thiz.gotDescription(configuration, streamId);
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
console.error("create answer error :" + error);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
}).catch(function (error) {
|
|
|
if (thiz.debug) {
|
|
|
console.error("set remote description is failed with error: " + error);
|
|
|
}
|
|
|
if (error.toString().indexOf("InvalidAccessError") > -1 || error.toString().indexOf("setRemoteDescription") > -1) {
|
|
|
/**
|
|
|
* This error generally occurs in codec incompatibility.
|
|
|
* AMS for a now supports H.264 codec. This error happens when some browsers try to open it from VP8.
|
|
|
*/
|
|
|
thiz.callbackError("notSetRemoteDescription");
|
|
|
}
|
|
|
});
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
this.takeCandidate = function (idOfTheStream, tmpLabel, tmpCandidate) {
|
|
|
var streamId = idOfTheStream;
|
|
|
var label = tmpLabel;
|
|
|
var candidateSdp = tmpCandidate;
|
|
|
|
|
|
var candidate = new RTCIceCandidate({
|
|
|
sdpMLineIndex: label,
|
|
|
candidate: candidateSdp
|
|
|
});
|
|
|
|
|
|
thiz.initPeerConnection(streamId);
|
|
|
|
|
|
if (thiz.remoteDescriptionSet[streamId] == true) {
|
|
|
thiz.addIceCandidate(streamId, candidate);
|
|
|
} else {
|
|
|
console.debug("Ice candidate is added to list because remote description is not set yet");
|
|
|
thiz.iceCandidateList[streamId].push(candidate);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
this.addIceCandidate = function (streamId, candidate) {
|
|
|
thiz.remotePeerConnection[streamId].addIceCandidate(candidate)
|
|
|
.then(function (response) {
|
|
|
if (thiz.debug) {
|
|
|
console.log("Candidate is added for stream " + streamId);
|
|
|
}
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
console.error("ice candiate cannot be added for stream id: " + streamId + " error is: " + error);
|
|
|
console.error(candidate);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
this.startPublishing = function (idOfStream) {
|
|
|
var streamId = idOfStream;
|
|
|
|
|
|
thiz.initPeerConnection(streamId);
|
|
|
|
|
|
thiz.remotePeerConnection[streamId].createOffer(thiz.sdp_constraints)
|
|
|
.then(function (configuration) {
|
|
|
thiz.gotDescription(configuration, streamId);
|
|
|
})
|
|
|
.catch(function (error) {
|
|
|
console.error("create offer error for stream id: " + streamId + " error: " + error);
|
|
|
});
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* If we have multiple video tracks in coming versions, this method may cause some issues
|
|
|
*/
|
|
|
this.getVideoSender = function (streamId) {
|
|
|
|
|
|
var videoSender = null;
|
|
|
if ((adapter.browserDetails.browser === 'chrome' ||
|
|
|
(adapter.browserDetails.browser === 'firefox' &&
|
|
|
adapter.browserDetails.version >= 64)) &&
|
|
|
'RTCRtpSender' in window &&
|
|
|
'setParameters' in window.RTCRtpSender.prototype) {
|
|
|
const senders = thiz.remotePeerConnection[streamId].getSenders();
|
|
|
|
|
|
for (let i = 0; i < senders.length; i++) {
|
|
|
if (senders[i].track != null && senders[i].track.kind == "video") {
|
|
|
videoSender = senders[i];
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
return videoSender;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* bandwidth is in kbps
|
|
|
*/
|
|
|
this.changeBandwidth = function (bandwidth, streamId) {
|
|
|
|
|
|
var errorDefinition = "";
|
|
|
|
|
|
var videoSender = thiz.getVideoSender(streamId);
|
|
|
|
|
|
if (videoSender != null) {
|
|
|
const parameters = videoSender.getParameters();
|
|
|
|
|
|
if (!parameters.encodings) {
|
|
|
parameters.encodings = [{}];
|
|
|
}
|
|
|
|
|
|
if (bandwidth === 'unlimited') {
|
|
|
delete parameters.encodings[0].maxBitrate;
|
|
|
} else {
|
|
|
parameters.encodings[0].maxBitrate = bandwidth * 1000;
|
|
|
}
|
|
|
|
|
|
return videoSender.setParameters(parameters)
|
|
|
} else {
|
|
|
errorDefinition = "Video sender not found to change bandwidth";
|
|
|
}
|
|
|
|
|
|
return Promise.reject(errorDefinition);
|
|
|
};
|
|
|
|
|
|
this.getStats = function (streamId) {
|
|
|
thiz.remotePeerConnection[streamId].getStats(null).then(stats => {
|
|
|
var bytesReceived = 0;
|
|
|
var packetsLost = 0;
|
|
|
var fractionLost = 0;
|
|
|
var currentTime = 0;
|
|
|
var bytesSent = 0;
|
|
|
|
|
|
stats.forEach(value => {
|
|
|
|
|
|
if (value.type == "inbound-rtp") {
|
|
|
bytesReceived += value.bytesReceived;
|
|
|
packetsLost += value.packetsLost;
|
|
|
fractionLost += value.fractionLost;
|
|
|
currentTime = value.timestamp;
|
|
|
} else if (value.type == "outbound-rtp") {
|
|
|
bytesSent += value.bytesSent
|
|
|
currentTime = value.timestamp
|
|
|
}
|
|
|
});
|
|
|
|
|
|
thiz.remotePeerConnectionStats[streamId].totalBytesReceived = bytesReceived;
|
|
|
thiz.remotePeerConnectionStats[streamId].packetsLost = packetsLost;
|
|
|
thiz.remotePeerConnectionStats[streamId].fractionLost = fractionLost;
|
|
|
thiz.remotePeerConnectionStats[streamId].currentTime = currentTime;
|
|
|
thiz.remotePeerConnectionStats[streamId].totalBytesSent = bytesSent;
|
|
|
|
|
|
thiz.callback("updated_stats", thiz.remotePeerConnectionStats[streamId]);
|
|
|
|
|
|
});
|
|
|
}
|
|
|
|
|
|
|
|
|
this.enableStats = function (streamId) {
|
|
|
thiz.remotePeerConnectionStats[streamId] = new PeerStats(streamId);
|
|
|
thiz.remotePeerConnectionStats[streamId].timerId = setInterval(() => {
|
|
|
thiz.getStats(streamId);
|
|
|
|
|
|
}, 5000);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* After calling this function, create new WebRTCAdaptor instance, don't use the the same objectone
|
|
|
* Because all streams are closed on server side as well when websocket connection is closed.
|
|
|
*/
|
|
|
this.closeWebSocket = function () {
|
|
|
for (var key in thiz.remotePeerConnection) {
|
|
|
thiz.remotePeerConnection[key].close();
|
|
|
}
|
|
|
//free the remote peer connection by initializing again
|
|
|
thiz.remotePeerConnection = new Array();
|
|
|
thiz.webSocketAdaptor.close();
|
|
|
}
|
|
|
|
|
|
function WebSocketAdaptor() {
|
|
|
var wsConn = new WebSocket(thiz.websocket_url);
|
|
|
|
|
|
var connected = false;
|
|
|
|
|
|
var pingTimerId = -1;
|
|
|
|
|
|
var clearPingTimer = function () {
|
|
|
if (pingTimerId != -1) {
|
|
|
if (thiz.debug) {
|
|
|
console.debug("Clearing ping message timer");
|
|
|
}
|
|
|
clearInterval(pingTimerId);
|
|
|
pingTimerId = -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
var sendPing = function () {
|
|
|
var jsCmd = {
|
|
|
command: "ping"
|
|
|
};
|
|
|
wsConn.send(JSON.stringify(jsCmd));
|
|
|
}
|
|
|
|
|
|
this.close = function () {
|
|
|
wsConn.close();
|
|
|
}
|
|
|
|
|
|
wsConn.onopen = function () {
|
|
|
if (thiz.debug) {
|
|
|
console.log("websocket connected");
|
|
|
}
|
|
|
|
|
|
pingTimerId = setInterval(() => {
|
|
|
sendPing();
|
|
|
}, 3000);
|
|
|
|
|
|
connected = true;
|
|
|
thiz.callback("initialized");
|
|
|
}
|
|
|
|
|
|
this.send = function (text) {
|
|
|
|
|
|
if (wsConn.readyState == 0 || wsConn.readyState == 2 || wsConn.readyState == 3) {
|
|
|
thiz.callbackError("WebSocketNotConnected");
|
|
|
return;
|
|
|
}
|
|
|
wsConn.send(text);
|
|
|
console.log("sent message:" + text);
|
|
|
}
|
|
|
|
|
|
this.isConnected = function () {
|
|
|
return connected;
|
|
|
}
|
|
|
|
|
|
wsConn.onmessage = function (event) {
|
|
|
var obj = JSON.parse(event.data);
|
|
|
|
|
|
if (obj.command == "start") {
|
|
|
//this command is received first, when publishing so playmode is false
|
|
|
|
|
|
if (thiz.debug) {
|
|
|
console.debug("received start command");
|
|
|
}
|
|
|
|
|
|
thiz.startPublishing(obj.streamId);
|
|
|
} else if (obj.command == "takeCandidate") {
|
|
|
|
|
|
if (thiz.debug) {
|
|
|
console.debug("received ice candidate for stream id " + obj.streamId);
|
|
|
console.debug(obj.candidate);
|
|
|
}
|
|
|
|
|
|
thiz.takeCandidate(obj.streamId, obj.label, obj.candidate);
|
|
|
|
|
|
} else if (obj.command == "takeConfiguration") {
|
|
|
|
|
|
if (thiz.debug) {
|
|
|
console.log("received remote description type for stream id: " + obj.streamId + " type: " + obj.type);
|
|
|
}
|
|
|
thiz.takeConfiguration(obj.streamId, obj.sdp, obj.type);
|
|
|
|
|
|
} else if (obj.command == "stop") {
|
|
|
console.debug("Stop command received");
|
|
|
thiz.closePeerConnection(obj.streamId);
|
|
|
} else if (obj.command == "error") {
|
|
|
thiz.callbackError(obj.definition);
|
|
|
} else if (obj.command == "notification") {
|
|
|
thiz.callback(obj.definition, obj);
|
|
|
if (obj.definition == "play_finished" || obj.definition == "publish_finished") {
|
|
|
thiz.closePeerConnection(obj.streamId);
|
|
|
}
|
|
|
} else if (obj.command == "streamInformation") {
|
|
|
thiz.callback(obj.command, obj);
|
|
|
} else if (obj.command == "pong") {
|
|
|
thiz.callback(obj.command);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
wsConn.onerror = function (error) {
|
|
|
console.log(" error occured: " + JSON.stringify(error));
|
|
|
clearPingTimer();
|
|
|
thiz.callbackError(error)
|
|
|
}
|
|
|
|
|
|
wsConn.onclose = function (event) {
|
|
|
connected = false;
|
|
|
console.log("connection closed.");
|
|
|
clearPingTimer();
|
|
|
thiz.callback("closed", event);
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
module.exports = WebRTCAdaptor
|
|
|
|
