478 lines
12 KiB
JavaScript
478 lines
12 KiB
JavaScript
/* global $, config, JitsiMeetJS */
|
|
import 'jquery';
|
|
import { setConfigFromURLParams } from '../../react/features/base/config/functions';
|
|
import { parseURLParams } from '../../react/features/base/util/parseURLParams';
|
|
import { parseURIString } from '../../react/features/base/util/uri';
|
|
import { validateLastNLimits, limitLastN } from '../../react/features/base/lastn/functions';
|
|
|
|
setConfigFromURLParams(config, {}, {}, window.location);
|
|
|
|
const params = parseURLParams(window.location, false, 'hash');
|
|
const { isHuman = false } = params;
|
|
const {
|
|
localVideo = config.startWithVideoMuted !== true,
|
|
remoteVideo = isHuman,
|
|
remoteAudio = isHuman,
|
|
autoPlayVideo = config.testing.noAutoPlayVideo !== true,
|
|
stageView = config.disableTileView
|
|
} = params;
|
|
|
|
let {
|
|
localAudio = config.startWithAudioMuted !== true,
|
|
} = params;
|
|
|
|
const { room: roomName } = parseURIString(window.location.toString());
|
|
|
|
let connection = null;
|
|
|
|
let connected = false;
|
|
|
|
let room = null;
|
|
|
|
let numParticipants = 1;
|
|
|
|
let localTracks = [];
|
|
const remoteTracks = {};
|
|
|
|
let maxFrameHeight = 0;
|
|
|
|
let selectedParticipant = null;
|
|
|
|
window.APP = {
|
|
conference: {
|
|
getStats() {
|
|
return room.connectionQuality.getStats();
|
|
},
|
|
getConnectionState() {
|
|
return room && room.getConnectionState();
|
|
},
|
|
muteAudio(mute) {
|
|
localAudio = mute;
|
|
for (let i = 0; i < localTracks.length; i++) {
|
|
if (localTracks[i].getType() === 'audio') {
|
|
if (mute) {
|
|
localTracks[i].mute();
|
|
}
|
|
else {
|
|
localTracks[i].unmute();
|
|
|
|
// if track was not added we need to add it to the peerconnection
|
|
if (!room.getLocalAudioTrack()) {
|
|
room.replaceTrack(null, localTracks[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
get room() {
|
|
return room;
|
|
},
|
|
get connection() {
|
|
return connection;
|
|
},
|
|
get numParticipants() {
|
|
return numParticipants;
|
|
},
|
|
get localTracks() {
|
|
return localTracks;
|
|
},
|
|
get remoteTracks() {
|
|
return remoteTracks;
|
|
},
|
|
get params() {
|
|
return {
|
|
roomName,
|
|
localAudio,
|
|
localVideo,
|
|
remoteVideo,
|
|
remoteAudio,
|
|
autoPlayVideo,
|
|
stageView
|
|
};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Simple emulation of jitsi-meet's screen layout behavior
|
|
*/
|
|
function updateMaxFrameHeight() {
|
|
if (!connected) {
|
|
return;
|
|
}
|
|
|
|
let newMaxFrameHeight;
|
|
|
|
if (stageView) {
|
|
newMaxFrameHeight = 2160;
|
|
}
|
|
else {
|
|
if (numParticipants <= 2) {
|
|
newMaxFrameHeight = 720;
|
|
} else if (numParticipants <= 4) {
|
|
newMaxFrameHeight = 360;
|
|
} else {
|
|
newMaxFrameHeight = 180;
|
|
}
|
|
}
|
|
|
|
if (room && maxFrameHeight !== newMaxFrameHeight) {
|
|
maxFrameHeight = newMaxFrameHeight;
|
|
room.setReceiverVideoConstraint(maxFrameHeight);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Simple emulation of jitsi-meet's lastN behavior
|
|
*/
|
|
function updateLastN() {
|
|
if (!connected) {
|
|
return;
|
|
}
|
|
|
|
let lastN = typeof config.channelLastN === 'undefined' ? -1 : config.channelLastN;
|
|
|
|
const limitedLastN = limitLastN(numParticipants, validateLastNLimits(config.lastNLimits));
|
|
|
|
if (limitedLastN !== undefined) {
|
|
lastN = lastN === -1 ? limitedLastN : Math.min(limitedLastN, lastN);
|
|
}
|
|
|
|
if (lastN === room.getLastN()) {
|
|
return;
|
|
}
|
|
|
|
room.setLastN(lastN);
|
|
}
|
|
|
|
/**
|
|
* Helper function to query whether a participant ID is a valid ID
|
|
* for stage view.
|
|
*/
|
|
function isValidStageViewParticipant(id) {
|
|
return (id !== room.myUserId() && room.getParticipantById(id));
|
|
}
|
|
|
|
/**
|
|
* Simple emulation of jitsi-meet's stage view participant selection behavior.
|
|
* Doesn't take into account pinning or screen sharing, and the initial behavior
|
|
* is slightly different.
|
|
* @returns Whether the selected participant changed.
|
|
*/
|
|
function selectStageViewParticipant(selected, previous) {
|
|
let newSelectedParticipant;
|
|
|
|
if (isValidStageViewParticipant(selected)) {
|
|
newSelectedParticipant = selected;
|
|
}
|
|
else {
|
|
newSelectedParticipant = previous.find(isValidStageViewParticipant);
|
|
}
|
|
if (newSelectedParticipant && newSelectedParticipant !== selectedParticipant) {
|
|
selectedParticipant = newSelectedParticipant;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Simple emulation of jitsi-meet's selectParticipants behavior
|
|
*/
|
|
function selectParticipants() {
|
|
if (!connected) {
|
|
return;
|
|
}
|
|
if (stageView) {
|
|
if (selectedParticipant) {
|
|
room.selectParticipants([selectedParticipant]);
|
|
}
|
|
}
|
|
else {
|
|
/* jitsi-meet's current Tile View behavior. */
|
|
const ids = room.getParticipants().map(participant => participant.getId());
|
|
room.selectParticipants(ids);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called when number of participants changes.
|
|
*/
|
|
function setNumberOfParticipants() {
|
|
$('#participants').text(numParticipants);
|
|
if (!stageView) {
|
|
selectParticipants();
|
|
updateMaxFrameHeight();
|
|
}
|
|
updateLastN();
|
|
}
|
|
|
|
/**
|
|
* Called when ICE connects
|
|
*/
|
|
function onConnectionEstablished() {
|
|
connected = true;
|
|
|
|
selectParticipants();
|
|
updateMaxFrameHeight();
|
|
updateLastN();
|
|
}
|
|
|
|
/**
|
|
* Handles dominant speaker changed.
|
|
* @param id
|
|
*/
|
|
function onDominantSpeakerChanged(selected, previous) {
|
|
if (selectStageViewParticipant(selected, previous)) {
|
|
selectParticipants();
|
|
}
|
|
updateMaxFrameHeight();
|
|
}
|
|
|
|
/**
|
|
* Handles local tracks.
|
|
* @param tracks Array with JitsiTrack objects
|
|
*/
|
|
function onLocalTracks(tracks = []) {
|
|
localTracks = tracks;
|
|
for (let i = 0; i < localTracks.length; i++) {
|
|
if (localTracks[i].getType() === 'video') {
|
|
$('body').append(`<video ${autoPlayVideo ? 'autoplay="1" ' : ''}id='localVideo${i}' />`);
|
|
localTracks[i].attach($(`#localVideo${i}`)[0]);
|
|
|
|
room.addTrack(localTracks[i]);
|
|
} else {
|
|
if (localAudio) {
|
|
room.addTrack(localTracks[i]);
|
|
} else {
|
|
localTracks[i].mute();
|
|
}
|
|
|
|
$('body').append(
|
|
`<audio autoplay='1' muted='true' id='localAudio${i}' />`);
|
|
localTracks[i].attach($(`#localAudio${i}`)[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles remote tracks
|
|
* @param track JitsiTrack object
|
|
*/
|
|
function onRemoteTrack(track) {
|
|
if (track.isLocal()
|
|
|| (track.getType() === 'video' && !remoteVideo) || (track.getType() === 'audio' && !remoteAudio)) {
|
|
return;
|
|
}
|
|
const participant = track.getParticipantId();
|
|
|
|
if (!remoteTracks[participant]) {
|
|
remoteTracks[participant] = [];
|
|
}
|
|
const idx = remoteTracks[participant].push(track);
|
|
const id = participant + track.getType() + idx;
|
|
|
|
if (track.getType() === 'video') {
|
|
$('body').append(`<video autoplay='1' id='${id}' />`);
|
|
} else {
|
|
$('body').append(`<audio autoplay='1' id='${id}' />`);
|
|
}
|
|
track.attach($(`#${id}`)[0]);
|
|
}
|
|
|
|
/**
|
|
* That function is executed when the conference is joined
|
|
*/
|
|
function onConferenceJoined() {
|
|
console.log('Conference joined');
|
|
}
|
|
|
|
/**
|
|
* Handles start muted events, when audio and/or video are muted due to
|
|
* startAudioMuted or startVideoMuted policy.
|
|
*/
|
|
function onStartMuted() {
|
|
// Give it some time, as it may be currently in the process of muting
|
|
setTimeout(() => {
|
|
const localAudioTrack = room.getLocalAudioTrack();
|
|
|
|
if (localAudio && localAudioTrack && localAudioTrack.isMuted()) {
|
|
localAudioTrack.unmute();
|
|
}
|
|
|
|
const localVideoTrack = room.getLocalVideoTrack();
|
|
|
|
if (localVideo && localVideoTrack && localVideoTrack.isMuted()) {
|
|
localVideoTrack.unmute();
|
|
}
|
|
}, 2000);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param id
|
|
*/
|
|
function onUserJoined(id) {
|
|
numParticipants++;
|
|
setNumberOfParticipants();
|
|
remoteTracks[id] = [];
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param id
|
|
*/
|
|
function onUserLeft(id) {
|
|
numParticipants--;
|
|
setNumberOfParticipants();
|
|
if (!remoteTracks[id]) {
|
|
return;
|
|
}
|
|
const tracks = remoteTracks[id];
|
|
|
|
for (let i = 0; i < tracks.length; i++) {
|
|
const container = $(`#${id}${tracks[i].getType()}${i + 1}`)[0];
|
|
|
|
if (container) {
|
|
tracks[i].detach(container);
|
|
container.parentElement.removeChild(container);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles private messages.
|
|
*
|
|
* @param {string} id - The sender ID.
|
|
* @param {string} text - The message.
|
|
* @returns {void}
|
|
*/
|
|
function onPrivateMessage(id, text) {
|
|
switch(text) {
|
|
case 'video on':
|
|
onVideoOnMessage();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles 'video on' private messages.
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
function onVideoOnMessage() {
|
|
console.debug('Turning my video on!');
|
|
|
|
const localVideoTrack = room.getLocalVideoTrack();
|
|
|
|
if (localVideoTrack && localVideoTrack.isMuted()) {
|
|
console.debug('Unmuting existing video track.');
|
|
localVideoTrack.unmute();
|
|
} else if (!localVideoTrack) {
|
|
JitsiMeetJS.createLocalTracks({ devices: [ 'video' ] })
|
|
.then(([ videoTrack ]) => videoTrack)
|
|
.catch(console.error)
|
|
.then(videoTrack => {
|
|
return room.replaceTrack(null, videoTrack);
|
|
})
|
|
.then(() => {
|
|
console.debug('Successfully added a new video track for unmute.');
|
|
});
|
|
} else {
|
|
console.log('No-op! We are already video unmuted!');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* That function is called when connection is established successfully
|
|
*/
|
|
function onConnectionSuccess() {
|
|
room = connection.initJitsiConference(roomName.toLowerCase(), config);
|
|
room.on(JitsiMeetJS.events.conference.STARTED_MUTED, onStartMuted);
|
|
room.on(JitsiMeetJS.events.conference.TRACK_ADDED, onRemoteTrack);
|
|
room.on(JitsiMeetJS.events.conference.CONFERENCE_JOINED, onConferenceJoined);
|
|
room.on(JitsiMeetJS.events.conference.CONNECTION_ESTABLISHED, onConnectionEstablished);
|
|
room.on(JitsiMeetJS.events.conference.USER_JOINED, onUserJoined);
|
|
room.on(JitsiMeetJS.events.conference.USER_LEFT, onUserLeft);
|
|
room.on(JitsiMeetJS.events.conference.PRIVATE_MESSAGE_RECEIVED, onPrivateMessage);
|
|
if (stageView) {
|
|
room.on(JitsiMeetJS.events.conference.DOMINANT_SPEAKER_CHANGED, onDominantSpeakerChanged);
|
|
}
|
|
|
|
const devices = [];
|
|
|
|
if (localVideo) {
|
|
devices.push('video');
|
|
}
|
|
|
|
// we always create audio local tracks
|
|
devices.push('audio');
|
|
|
|
if (devices.length > 0) {
|
|
JitsiMeetJS.createLocalTracks({ devices })
|
|
.then(onLocalTracks)
|
|
.then(() => {
|
|
room.join();
|
|
})
|
|
.catch(error => {
|
|
throw error;
|
|
});
|
|
} else {
|
|
room.join();
|
|
}
|
|
|
|
updateMaxFrameHeight();
|
|
}
|
|
|
|
/**
|
|
* This function is called when the connection fail.
|
|
*/
|
|
function onConnectionFailed() {
|
|
console.error('Connection Failed!');
|
|
}
|
|
|
|
/**
|
|
* This function is called when we disconnect.
|
|
*/
|
|
function disconnect() {
|
|
console.log('disconnect!');
|
|
connection.removeEventListener(
|
|
JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED,
|
|
onConnectionSuccess);
|
|
connection.removeEventListener(
|
|
JitsiMeetJS.events.connection.CONNECTION_FAILED,
|
|
onConnectionFailed);
|
|
connection.removeEventListener(
|
|
JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED,
|
|
disconnect);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
function unload() {
|
|
for (let i = 0; i < localTracks.length; i++) {
|
|
localTracks[i].dispose();
|
|
}
|
|
room.leave();
|
|
connection.disconnect();
|
|
}
|
|
|
|
$(window).bind('beforeunload', unload);
|
|
$(window).bind('unload', unload);
|
|
|
|
JitsiMeetJS.setLogLevel(JitsiMeetJS.logLevels.ERROR);
|
|
|
|
JitsiMeetJS.init(config);
|
|
|
|
config.serviceUrl = config.bosh = `${config.websocket || config.bosh}?room=${roomName.toLowerCase()}`;
|
|
if (config.websocketKeepAliveUrl) {
|
|
config.websocketKeepAliveUrl += `?room=${roomName.toLowerCase()}`;
|
|
}
|
|
|
|
connection = new JitsiMeetJS.JitsiConnection(null, null, config);
|
|
connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED, onConnectionSuccess);
|
|
connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_FAILED, onConnectionFailed);
|
|
connection.addEventListener(JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED, disconnect);
|
|
connection.connect();
|