jiti-meet/modules/devices/mediaDeviceHelper.js

295 lines
11 KiB
JavaScript

/* global APP, JitsiMeetJS */
import {
notifyCameraError,
notifyMicError
} from '../../react/features/base/devices/actions.web';
import {
getAudioOutputDeviceId
} from '../../react/features/base/devices/functions.web';
import {
getUserSelectedCameraDeviceId,
getUserSelectedMicDeviceId,
getUserSelectedOutputDeviceId,
updateSettings
} from '../../react/features/base/settings';
/**
* Determines if currently selected audio output device should be changed after
* list of available devices has been changed.
* @param {MediaDeviceInfo[]} newDevices
* @returns {string|undefined} - ID of new audio output device to use, undefined
* if audio output device should not be changed.
*/
function getNewAudioOutputDevice(newDevices) {
if (!JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
return;
}
const selectedAudioOutputDeviceId = getAudioOutputDeviceId();
const availableAudioOutputDevices = newDevices.filter(
d => d.kind === 'audiooutput');
// Switch to 'default' audio output device if we don't have the selected one
// available anymore.
if (selectedAudioOutputDeviceId !== 'default'
&& !availableAudioOutputDevices.find(d =>
d.deviceId === selectedAudioOutputDeviceId)) {
return 'default';
}
const preferredAudioOutputDeviceId = getUserSelectedOutputDeviceId(APP.store.getState());
// if the preferred one is not the selected and is available in the new devices
// we want to use it as it was just added
if (preferredAudioOutputDeviceId
&& preferredAudioOutputDeviceId !== selectedAudioOutputDeviceId
&& availableAudioOutputDevices.find(d => d.deviceId === preferredAudioOutputDeviceId)) {
return preferredAudioOutputDeviceId;
}
}
/**
* Determines if currently selected audio input device should be changed after
* list of available devices has been changed.
* @param {MediaDeviceInfo[]} newDevices
* @param {JitsiLocalTrack} localAudio
* @param {boolean} newLabel
* @returns {string|undefined} - ID of new microphone device to use, undefined
* if audio input device should not be changed.
*/
function getNewAudioInputDevice(newDevices, localAudio, newLabel) {
const availableAudioInputDevices = newDevices.filter(
d => d.kind === 'audioinput');
const selectedAudioInputDeviceId = getUserSelectedMicDeviceId(APP.store.getState());
const selectedAudioInputDevice = availableAudioInputDevices.find(
d => d.deviceId === selectedAudioInputDeviceId);
const localAudioDeviceId = localAudio?.getDeviceId();
const localAudioDevice = availableAudioInputDevices.find(
d => d.deviceId === localAudioDeviceId);
// Here we handle case when no device was initially plugged, but
// then it's connected OR new device was connected when previous
// track has ended.
if (!localAudio || localAudio.disposed || localAudio.isEnded()) {
// If we have new audio device and permission to use it was granted
// (label is not an empty string), then we will try to use the first
// available device.
if (selectedAudioInputDevice && selectedAudioInputDeviceId) {
return selectedAudioInputDeviceId;
} else if (availableAudioInputDevices.length
&& availableAudioInputDevices[0].label !== '') {
return availableAudioInputDevices[0].deviceId;
}
} else if (selectedAudioInputDevice
&& selectedAudioInputDeviceId !== localAudioDeviceId) {
if (newLabel) {
// If a Firefox user with manual permission prompt chose a different
// device from what we have stored as the preferred device we accept
// and store that as the new preferred device.
APP.store.dispatch(updateSettings({
userSelectedMicDeviceId: localAudioDeviceId,
userSelectedMicDeviceLabel: localAudioDevice.label
}));
} else {
// And here we handle case when we already have some device working,
// but we plug-in a "preferred" (previously selected in settings, stored
// in local storage) device.
return selectedAudioInputDeviceId;
}
}
}
/**
* Determines if currently selected video input device should be changed after
* list of available devices has been changed.
* @param {MediaDeviceInfo[]} newDevices
* @param {JitsiLocalTrack} localVideo
* @param {boolean} newLabel
* @returns {string|undefined} - ID of new camera device to use, undefined
* if video input device should not be changed.
*/
function getNewVideoInputDevice(newDevices, localVideo, newLabel) {
const availableVideoInputDevices = newDevices.filter(
d => d.kind === 'videoinput');
const selectedVideoInputDeviceId = getUserSelectedCameraDeviceId(APP.store.getState());
const selectedVideoInputDevice = availableVideoInputDevices.find(
d => d.deviceId === selectedVideoInputDeviceId);
const localVideoDeviceId = localVideo?.getDeviceId();
const localVideoDevice = availableVideoInputDevices.find(
d => d.deviceId === localVideoDeviceId);
// Here we handle case when no video input device was initially plugged,
// but then device is connected OR new device was connected when
// previous track has ended.
if (!localVideo || localVideo.disposed || localVideo.isEnded()) {
// If we have new video device and permission to use it was granted
// (label is not an empty string), then we will try to use the first
// available device.
if (selectedVideoInputDevice && selectedVideoInputDeviceId) {
return selectedVideoInputDeviceId;
} else if (availableVideoInputDevices.length
&& availableVideoInputDevices[0].label !== '') {
return availableVideoInputDevices[0].deviceId;
}
} else if (selectedVideoInputDevice
&& selectedVideoInputDeviceId !== localVideoDeviceId) {
if (newLabel) {
// If a Firefox user with manual permission prompt chose a different
// device from what we have stored as the preferred device we accept
// and store that as the new preferred device.
APP.store.dispatch(updateSettings({
userSelectedCameraDeviceId: localVideoDeviceId,
userSelectedCameraDeviceLabel: localVideoDevice.label
}));
} else {
// And here we handle case when we already have some device working,
// but we plug-in a "preferred" (previously selected in settings, stored
// in local storage) device.
return selectedVideoInputDeviceId;
}
}
}
export default {
/**
* Determines if currently selected media devices should be changed after
* list of available devices has been changed.
* @param {MediaDeviceInfo[]} newDevices
* @param {JitsiLocalTrack} localVideo
* @param {JitsiLocalTrack} localAudio
* @returns {{
* audioinput: (string|undefined),
* videoinput: (string|undefined),
* audiooutput: (string|undefined)
* }}
*/
getNewMediaDevicesAfterDeviceListChanged( // eslint-disable-line max-params
newDevices,
localVideo,
localAudio,
newLabels) {
return {
audioinput: getNewAudioInputDevice(newDevices, localAudio, newLabels),
videoinput: getNewVideoInputDevice(newDevices, localVideo, newLabels),
audiooutput: getNewAudioOutputDevice(newDevices)
};
},
/**
* Checks if the only difference between an object of known devices compared
* to an array of new devices are only the labels for the devices.
* @param {Object} oldDevices
* @param {MediaDeviceInfo[]} newDevices
* @returns {boolean}
*/
newDeviceListAddedLabelsOnly(oldDevices, newDevices) {
const oldDevicesFlattend = oldDevices.audioInput.concat(oldDevices.audioOutput).concat(oldDevices.videoInput);
if (oldDevicesFlattend.length !== newDevices.length) {
return false;
}
oldDevicesFlattend.forEach(oldDevice => {
if (oldDevice.label !== '') {
return false;
}
const newDevice = newDevices.find(nd => nd.deviceId === oldDevice.deviceId);
if (!newDevice || newDevice.label === '') {
return false;
}
});
return true;
},
/**
* Tries to create new local tracks for new devices obtained after device
* list changed. Shows error dialog in case of failures.
* @param {function} createLocalTracks
* @param {string} (cameraDeviceId)
* @param {string} (micDeviceId)
* @returns {Promise.<JitsiLocalTrack[]>}
*/
createLocalTracksAfterDeviceListChanged(
createLocalTracks,
cameraDeviceId,
micDeviceId) {
let audioTrackError;
let videoTrackError;
const audioRequested = Boolean(micDeviceId);
const videoRequested = Boolean(cameraDeviceId);
if (audioRequested && videoRequested) {
// First we try to create both audio and video tracks together.
return (
createLocalTracks({
devices: [ 'audio', 'video' ],
cameraDeviceId,
micDeviceId
})
// If we fail to do this, try to create them separately.
.catch(() => Promise.all([
createAudioTrack(false).then(([ stream ]) => stream),
createVideoTrack(false).then(([ stream ]) => stream)
]))
.then(tracks => {
if (audioTrackError) {
APP.store.dispatch(notifyMicError(audioTrackError));
}
if (videoTrackError) {
APP.store.dispatch(notifyCameraError(videoTrackError));
}
return tracks.filter(t => typeof t !== 'undefined');
}));
} else if (videoRequested && !audioRequested) {
return createVideoTrack();
} else if (audioRequested && !videoRequested) {
return createAudioTrack();
}
return Promise.resolve([]);
/**
*
*/
function createAudioTrack(showError = true) {
return (
createLocalTracks({
devices: [ 'audio' ],
cameraDeviceId: null,
micDeviceId
})
.catch(err => {
audioTrackError = err;
showError && APP.store.dispatch(notifyMicError(err));
return [];
}));
}
/**
*
*/
function createVideoTrack(showError = true) {
return (
createLocalTracks({
devices: [ 'video' ],
cameraDeviceId,
micDeviceId: null
})
.catch(err => {
videoTrackError = err;
showError && APP.store.dispatch(notifyCameraError(err));
return [];
}));
}
}
};