Files
sean 0e8a8b3028
Some checks failed
deploy-testing / deploy (push) Has been cancelled
Initial testing snapshot
2026-11-17 16:15:01 -05:00

589 lines
18 KiB
JavaScript

// Last updated On: January 18, 2019
// Muaz Khan - www.MuazKhan.com
// MIT License - www.WebRTC-Experiment.com/licence
// Documentation - github.com/muaz-khan/WebRTC-Experiment/tree/master/Pluginfree-Screen-Sharing
var isbroadcaster = false;
var conference = function(config) {
if (typeof adapter === 'undefined' || typeof adapter.browserDetails === 'undefined') {
// https://webrtc.github.io/adapter/adapter-latest.js
console.warn('adapter.js is recommended.');
} else {
window.adapter = {
browserDetails: {
browser: 'chrome'
}
};
}
var self = {
userToken: uniqueToken()
},
channels = '--',
isGetNewRoom = true,
participants = 0,
defaultSocket = {};
var sockets = [];
function openDefaultSocket() {
defaultSocket = config.openSocket({
onmessage: defaultSocketResponse,
callback: function(socket) {
defaultSocket = socket;
}
});
}
function defaultSocketResponse(response) {
if (response.userToken == self.userToken) return;
if (isGetNewRoom && response.roomToken && response.broadcaster) config.onRoomFound(response);
if (response.newParticipant) onNewParticipant(response.newParticipant);
if (response.userToken && response.joinUser == self.userToken && response.participant && channels.indexOf(response.userToken) == -1) {
channels += response.userToken + '--';
openSubSocket({
isofferer: true,
channel: response.channel || response.userToken,
closeSocket: true
});
}
}
function openSubSocket(_config) {
if (!_config.channel) return;
var socketConfig = {
channel: _config.channel,
onmessage: socketResponse,
onopen: function() {
if (isofferer && !peer) initPeer();
sockets[sockets.length] = socket;
}
};
socketConfig.callback = function(_socket) {
socket = _socket;
this.onopen();
};
var socket = config.openSocket(socketConfig),
isofferer = _config.isofferer,
gotstream,
htmlElement = document.createElement('video'),
inner = {},
peer;
var peerConfig = {
oniceconnectionstatechange: function(p) {
if (!isofferer) return;
if (p && p.iceConnectionState) {
config.oniceconnectionstatechange(p.iceConnectionState);
}
},
attachStream: config.attachStream,
onICE: function(candidate) {
socket && socket.send({
userToken: self.userToken,
candidate: {
sdpMLineIndex: candidate.sdpMLineIndex,
candidate: JSON.stringify(candidate.candidate)
}
});
},
onRemoteStream: function(stream) {
if (isbroadcaster) return;
try {
htmlElement.setAttributeNode(document.createAttribute('autoplay'));
htmlElement.setAttributeNode(document.createAttribute('playsinline'));
htmlElement.setAttributeNode(document.createAttribute('controls'));
} catch (e) {
htmlElement.setAttribute('autoplay', true);
htmlElement.setAttribute('playsinline', true);
htmlElement.setAttribute('controls', true);
}
htmlElement.srcObject = stream;
_config.stream = stream;
afterRemoteStreamStartedFlowing();
}
};
function initPeer(offerSDP) {
if (!offerSDP) peerConfig.onOfferSDP = sendsdp;
else {
peerConfig.offerSDP = offerSDP;
peerConfig.onAnswerSDP = sendsdp;
}
peer = RTCPeerConnectionHandler(peerConfig);
}
function afterRemoteStreamStartedFlowing() {
gotstream = true;
config.onRemoteStream({
video: htmlElement
});
/* closing sub-socket here on the offerer side */
if (_config.closeSocket) socket = null;
}
function sendsdp(sdp) {
sdp = JSON.stringify(sdp);
var part = parseInt(sdp.length / 3);
var firstPart = sdp.slice(0, part),
secondPart = sdp.slice(part, sdp.length - 1),
thirdPart = '';
if (sdp.length > part + part) {
secondPart = sdp.slice(part, part + part);
thirdPart = sdp.slice(part + part, sdp.length);
}
socket && socket.send({
userToken: self.userToken,
firstPart: firstPart
});
socket && socket.send({
userToken: self.userToken,
secondPart: secondPart
});
socket && socket.send({
userToken: self.userToken,
thirdPart: thirdPart
});
}
function socketResponse(response) {
if (response.userToken == self.userToken) return;
if (response.firstPart || response.secondPart || response.thirdPart) {
if (response.firstPart) {
inner.firstPart = response.firstPart;
if (inner.secondPart && inner.thirdPart) selfInvoker();
}
if (response.secondPart) {
inner.secondPart = response.secondPart;
if (inner.firstPart && inner.thirdPart) selfInvoker();
}
if (response.thirdPart) {
inner.thirdPart = response.thirdPart;
if (inner.firstPart && inner.secondPart) selfInvoker();
}
}
if (response.candidate && !gotstream) {
peer && peer.addICE({
sdpMLineIndex: response.candidate.sdpMLineIndex,
candidate: JSON.parse(response.candidate.candidate)
});
}
if (response.left) {
participants--;
if (isofferer && config.onNewParticipant) config.onNewParticipant(participants);
if (peer && peer.peer) {
peer.peer.close();
peer.peer = null;
}
}
}
var invokedOnce = false;
function selfInvoker() {
if (invokedOnce) return;
invokedOnce = true;
inner.sdp = JSON.parse(inner.firstPart + inner.secondPart + inner.thirdPart);
if (isofferer && inner.sdp.type == 'answer') {
peer.addAnswerSDP(inner.sdp);
participants++;
if (config.onNewParticipant) config.onNewParticipant(participants);
} else initPeer(inner.sdp);
}
}
function leave() {
var length = sockets.length;
for (var i = 0; i < length; i++) {
var socket = sockets[i];
if (socket) {
socket.send({
left: true,
userToken: self.userToken
});
delete sockets[i];
}
}
// if owner leaves; try to remove his room from all other users side
if (isbroadcaster) {
defaultSocket.send({
left: true,
userToken: self.userToken,
roomToken: self.roomToken
});
}
if (config.attachStream) config.attachStream.stop();
}
window.addEventListener('beforeunload', function() {
leave();
}, false);
window.addEventListener('keyup', function(e) {
if (e.keyCode == 116)
leave();
}, false);
function startBroadcasting() {
defaultSocket && defaultSocket.send({
roomToken: self.roomToken,
roomName: self.roomName,
broadcaster: self.userToken
});
setTimeout(startBroadcasting, 3000);
}
function onNewParticipant(channel) {
if (!channel || channels.indexOf(channel) != -1 || channel == self.userToken) return;
channels += channel + '--';
var new_channel = uniqueToken();
openSubSocket({
channel: new_channel,
closeSocket: true
});
defaultSocket.send({
participant: true,
userToken: self.userToken,
joinUser: channel,
channel: new_channel
});
}
function uniqueToken() {
return Math.random().toString(36).substr(2, 35);
}
openDefaultSocket();
return {
createRoom: function(_config) {
self.roomName = _config.roomName || 'Anonymous';
self.roomToken = uniqueToken();
isbroadcaster = true;
isGetNewRoom = false;
startBroadcasting();
},
joinRoom: function(_config) {
self.roomToken = _config.roomToken;
isGetNewRoom = false;
openSubSocket({
channel: self.userToken
});
defaultSocket.send({
participant: true,
userToken: self.userToken,
joinUser: _config.joinUser
});
}
};
};
// Documentation - https://github.com/muaz-khan/WebRTC-Experiment/tree/master/RTCPeerConnection
// RTCPeerConnection-v1.5.js
var iceServers = [];
if (typeof IceServersHandler !== 'undefined') {
iceServers = IceServersHandler.getIceServers();
}
iceServers = {
iceServers: iceServers,
iceTransportPolicy: 'all',
bundlePolicy: 'max-bundle',
iceCandidatePoolSize: 0
};
if (adapter.browserDetails.browser !== 'chrome') {
iceServers = {
iceServers: iceServers.iceServers
};
}
var dontDuplicateOnAddTrack = {};
function RTCPeerConnectionHandler(options) {
var w = window,
PeerConnection = w.RTCPeerConnection || w.mozRTCPeerConnection || w.webkitRTCPeerConnection,
SessionDescription = w.RTCSessionDescription || w.mozRTCSessionDescription,
IceCandidate = w.RTCIceCandidate || w.mozRTCIceCandidate;
var peer = new PeerConnection(iceServers);
peer.onicecandidate = function(event) {
if (event.candidate)
options.onICE(event.candidate);
};
// attachStream = MediaStream;
if (options.attachStream) {
if ('addStream' in peer) {
peer.addStream(options.attachStream);
} else if ('addTrack' in peer) {
options.attachStream.getTracks().forEach(function(track) {
peer.addTrack(track, options.attachStream);
});
} else {
throw new Error('WebRTC addStream/addTrack is not supported.');
}
}
// attachStreams[0] = audio-stream;
// attachStreams[1] = video-stream;
// attachStreams[2] = screen-capturing-stream;
if (options.attachStreams && options.attachStream.length) {
var streams = options.attachStreams;
for (var i = 0; i < streams.length; i++) {
var stream = streams[i];
if ('addStream' in peer) {
peer.addStream(stream);
} else if ('addTrack' in peer) {
stream.getTracks().forEach(function(track) {
peer.addTrack(track, stream);
});
} else {
throw new Error('WebRTC addStream/addTrack is not supported.');
}
}
}
if ('addStream' in peer) {
peer.onaddstream = function(event) {
var remoteMediaStream = event.stream;
// onRemoteStreamEnded(MediaStream)
addStreamStopListener(remoteMediaStream, function() {
if (options.onRemoteStreamEnded) options.onRemoteStreamEnded(remoteMediaStream);
});
// onRemoteStream(MediaStream)
if (options.onRemoteStream) options.onRemoteStream(remoteMediaStream);
console.debug('on:add:stream', remoteMediaStream);
};
} else if ('addTrack' in peer) {
peer.ontrack = peer.onaddtrack = function(event) {
event.stream = event.streams[event.streams.length - 1];
if (dontDuplicateOnAddTrack[event.stream.id] && adapter.browserDetails.browser !== 'safari') return;
dontDuplicateOnAddTrack[event.stream.id] = true;
var remoteMediaStream = event.stream;
// onRemoteStreamEnded(MediaStream)
addStreamStopListener(remoteMediaStream, function() {
if (options.onRemoteStreamEnded) options.onRemoteStreamEnded(remoteMediaStream);
});
// onRemoteStream(MediaStream)
if (options.onRemoteStream) options.onRemoteStream(remoteMediaStream);
console.debug('on:add:stream', remoteMediaStream);
};
} else {
throw new Error('WebRTC addStream/addTrack is not supported.');
}
var sdpConstraints = {
OfferToReceiveAudio: true,
OfferToReceiveVideo: true
};
if (isbroadcaster) {
sdpConstraints = {
OfferToReceiveAudio: false,
OfferToReceiveVideo: false
};
}
// onOfferSDP(RTCSessionDescription)
function createOffer() {
if (!options.onOfferSDP) return;
peer.createOffer(sdpConstraints).then(function(sessionDescription) {
sessionDescription.sdp = setBandwidth(sessionDescription.sdp);
peer.setLocalDescription(sessionDescription).then(function() {
options.onOfferSDP(sessionDescription);
}).catch(onSdpError);
}).catch(onSdpError);
}
// onAnswerSDP(RTCSessionDescription)
function createAnswer() {
if (!options.onAnswerSDP) return;
//options.offerSDP.sdp = addStereo(options.offerSDP.sdp);
peer.setRemoteDescription(new SessionDescription(options.offerSDP)).then(function() {
peer.createAnswer(sdpConstraints).then(function(sessionDescription) {
sessionDescription.sdp = setBandwidth(sessionDescription.sdp);
peer.setLocalDescription(sessionDescription).then(function() {
options.onAnswerSDP(sessionDescription);
}).catch(onSdpError);
}).catch(onSdpError);
}).catch(onSdpError);
}
function setBandwidth(sdp) {
if (adapter.browserDetails.browser === 'firefox') return sdp;
if (adapter.browserDetails.browser === 'safari') return sdp;
if (isEdge) return sdp;
// https://github.com/muaz-khan/RTCMultiConnection/blob/master/dev/CodecsHandler.js
if (typeof CodecsHandler !== 'undefined') {
sdp = CodecsHandler.preferCodec(sdp, 'vp9');
}
// https://github.com/muaz-khan/RTCMultiConnection/blob/master/dev/BandwidthHandler.js
if (typeof BandwidthHandler !== 'undefined') {
window.isFirefox = adapter.browserDetails.browser === 'firefox';
var bandwidth = {
screen: 512, // 300kbits minimum
video: 512 // 256kbits (both min-max)
};
var isScreenSharing = false;
sdp = BandwidthHandler.setApplicationSpecificBandwidth(sdp, bandwidth, isScreenSharing);
sdp = BandwidthHandler.setVideoBitrates(sdp, {
min: bandwidth.video,
max: bandwidth.video
});
return sdp;
}
// removing existing bandwidth lines
sdp = sdp.replace(/b=AS([^\r\n]+\r\n)/g, '');
// "300kbit/s" for screen sharing
sdp = sdp.replace(/a=mid:video\r\n/g, 'a=mid:video\r\nb=AS:300\r\n');
return sdp;
}
peer.isConnected = false;
peer.oniceconnectionstatechange = peer.onsignalingstatechange = function() {
if(peer && peer.isConnected && peer.iceConnectionState == 'failed') return;
options.oniceconnectionstatechange(peer);
};
createOffer();
createAnswer();
function onSdpError(e) {
console.error('sdp error:', JSON.stringify(e, null, '\t'));
}
return {
addAnswerSDP: function(sdp) {
console.log('setting remote description', sdp.sdp);
peer.setRemoteDescription(new SessionDescription(sdp)).catch(onSdpError).then(function() {
peer.isConnected = true;
});
},
addICE: function(candidate) {
console.log('adding candidate', candidate.candidate);
peer.addIceCandidate(new IceCandidate({
sdpMLineIndex: candidate.sdpMLineIndex,
candidate: candidate.candidate
}));
},
peer: peer
};
}
var isEdge = navigator.userAgent.indexOf('Edge') !== -1 && (!!navigator.msSaveOrOpenBlob || !!navigator.msSaveBlob);
// getUserMedia
var video_constraints = {
mandatory: {},
optional: []
};
function getUserMedia(options) {
function streaming(stream) {
if (typeof options.onsuccess === 'function') {
options.onsuccess(stream);
}
media = stream;
}
if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
navigator.mediaDevices.getUserMedia(options.constraints || {
audio: false,
video: video_constraints
}).then(streaming).catch(options.onerror || function(e) {
console.error(e);
});
return;
}
var n = navigator,
media;
n.getMedia = n.getUserMedia || n.webkitGetUserMedia || n.mozGetUserMedia;
n.getMedia(options.constraints || {
audio: true,
video: video_constraints
}, streaming, options.onerror || function(e) {
console.error(e);
});
return media;
}
function addStreamStopListener(stream, callback) {
stream.addEventListener('ended', function() {
callback();
callback = function() {};
}, false);
stream.addEventListener('inactive', function() {
callback();
callback = function() {};
}, false);
stream.getTracks().forEach(function(track) {
track.addEventListener('ended', function() {
callback();
callback = function() {};
}, false);
track.addEventListener('inactive', function() {
callback();
callback = function() {};
}, false);
});
}