ambiser
/
openvidu
mirror of https://github.com/OpenVidu/openvidu.git
8
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

openvidu-browser: Refactored some methods for them to use async/await 

Updated initPublisher and getUserMedia
pull/750/head
csantosm 2022-08-17 16:13:16 +02:00
parent 1704bb2c8c
commit c0e45e8df7
2 changed files with 130 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
openvidu-browser/src/OpenVidu/OpenVidu.ts
View File

@ -499,17 +499,16 @@ export class OpenVidu {
* ``` * ```
*/ */
getUserMedia(options: PublisherProperties): Promise<MediaStream> { getUserMedia(options: PublisherProperties): Promise<MediaStream> {
return new Promise<MediaStream>((resolve, reject) => { return new Promise<MediaStream>(async (resolve, reject) => {
const askForAudioStreamOnly = (previousMediaStream: MediaStream, constraints: MediaStreamConstraints) => { const askForAudioStreamOnly = async (previousMediaStream: MediaStream, constraints: MediaStreamConstraints) => {
const definedAudioConstraint = ((constraints.audio === undefined) ? true : constraints.audio); const definedAudioConstraint = ((constraints.audio === undefined) ? true : constraints.audio);
const constraintsAux: MediaStreamConstraints = { audio: definedAudioConstraint, video: false }; const constraintsAux: MediaStreamConstraints = { audio: definedAudioConstraint, video: false };
navigator.mediaDevices.getUserMedia(constraintsAux) try {
.then(audioOnlyStream => { const audioOnlyStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
previousMediaStream.addTrack(audioOnlyStream.getAudioTracks()[0]); previousMediaStream.addTrack(audioOnlyStream.getAudioTracks()[0]);
return resolve(previousMediaStream); return resolve(previousMediaStream);
}) } catch (error) {
.catch(error => {
previousMediaStream.getAudioTracks().forEach((track) => { previousMediaStream.getAudioTracks().forEach((track) => {
track.stop(); track.stop();
}); });
@ -517,11 +516,11 @@ export class OpenVidu {
track.stop(); track.stop();
}); });
return reject(this.generateAudioDeviceError(error, constraintsAux)); return reject(this.generateAudioDeviceError(error, constraintsAux));
}); }
} }
this.generateMediaConstraints(options).then(myConstraints => { try {
const myConstraints = await this.generateMediaConstraints(options);
if (!!myConstraints.videoTrack && !!myConstraints.audioTrack || if (!!myConstraints.videoTrack && !!myConstraints.audioTrack ||
!!myConstraints.audioTrack && myConstraints.constraints?.video === false || !!myConstraints.audioTrack && myConstraints.constraints?.video === false ||
!!myConstraints.videoTrack && myConstraints.constraints?.audio === false) { !!myConstraints.videoTrack && myConstraints.constraints?.audio === false) {
@ -550,22 +549,21 @@ export class OpenVidu {
mustAskForAudioTrackLater = !myConstraints.audioTrack && (options.audioSource !== null && options.audioSource !== false); mustAskForAudioTrackLater = !myConstraints.audioTrack && (options.audioSource !== null && options.audioSource !== false);
if (navigator.mediaDevices['getDisplayMedia'] && !platform.isElectron()) { if (navigator.mediaDevices['getDisplayMedia'] && !platform.isElectron()) {
// getDisplayMedia supported // getDisplayMedia supported
navigator.mediaDevices['getDisplayMedia']({ video: true }) try {
.then(mediaStream => { const mediaStream = await navigator.mediaDevices['getDisplayMedia']({ video: true });
this.addAlreadyProvidedTracks(myConstraints, mediaStream); this.addAlreadyProvidedTracks(myConstraints, mediaStream);
if (mustAskForAudioTrackLater) { if (mustAskForAudioTrackLater) {
askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints); await askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints);
return;
} else { } else {
return resolve(mediaStream); return resolve(mediaStream);
} }
})
.catch(error => { } catch (error) {
let errorName: OpenViduErrorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED; let errorName: OpenViduErrorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED;
const errorMessage = error.toString(); const errorMessage = error.toString();
return reject(new OpenViduError(errorName, errorMessage)); return reject(new OpenViduError(errorName, errorMessage));
}); }
return;
} else { } else {
// getDisplayMedia NOT supported. Can perform getUserMedia below with already calculated constraints // getDisplayMedia NOT supported. Can perform getUserMedia below with already calculated constraints
} }
@ -575,17 +573,15 @@ export class OpenVidu {
} }
// Use already calculated constraints // Use already calculated constraints
const constraintsAux = mustAskForAudioTrackLater ? { video: myConstraints.constraints!.video } : myConstraints.constraints; const constraintsAux = mustAskForAudioTrackLater ? { video: myConstraints.constraints!.video } : myConstraints.constraints;
navigator.mediaDevices.getUserMedia(constraintsAux) try {
.then(mediaStream => { const mediaStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
this.addAlreadyProvidedTracks(myConstraints, mediaStream); this.addAlreadyProvidedTracks(myConstraints, mediaStream);
if (mustAskForAudioTrackLater) { if (mustAskForAudioTrackLater) {
askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints); await askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints);
return;
} else { } else {
return resolve(mediaStream); return resolve(mediaStream);
} }
}) } catch (error) {
.catch(error => {
let errorName: OpenViduErrorName; let errorName: OpenViduErrorName;
const errorMessage = error.toString(); const errorMessage = error.toString();
if (!(options.videoSource === 'screen')) { if (!(options.videoSource === 'screen')) {
@ -594,9 +590,11 @@ export class OpenVidu {
errorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED; errorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED;
} }
return reject(new OpenViduError(errorName, errorMessage)); return reject(new OpenViduError(errorName, errorMessage));
});
} }
}).catch((error: OpenViduError) => reject(error)); }
} catch (error) {
reject(error);
}
}); });
} }

80
openvidu-browser/src/OpenVidu/Publisher.ts
View File

@ -358,7 +358,7 @@ export class Publisher extends StreamManager {
* @hidden * @hidden
*/ */
initialize(): Promise<void> { initialize(): Promise<void> {
return new Promise((resolve, reject) => { return new Promise(async (resolve, reject) => {
let constraints: MediaStreamConstraints = {}; let constraints: MediaStreamConstraints = {};
let constraintsAux: MediaStreamConstraints = {}; let constraintsAux: MediaStreamConstraints = {};
@ -477,7 +477,7 @@ export class Publisher extends StreamManager {
return resolve(); return resolve();
}; };
const getMediaSuccess = (mediaStream: MediaStream, definedAudioConstraint) => { const getMediaSuccess = async (mediaStream: MediaStream, definedAudioConstraint) => {
this.clearPermissionDialogTimer(startTime, timeForDialogEvent); this.clearPermissionDialogTimer(startTime, timeForDialogEvent);
if (this.stream.isSendScreen() && this.stream.isSendAudio()) { if (this.stream.isSendScreen() && this.stream.isSendAudio()) {
// When getting desktop as user media audio constraint must be false. Now we can ask for it if required // When getting desktop as user media audio constraint must be false. Now we can ask for it if required
@ -486,13 +486,13 @@ export class Publisher extends StreamManager {
startTime = Date.now(); startTime = Date.now();
this.setPermissionDialogTimer(timeForDialogEvent); this.setPermissionDialogTimer(timeForDialogEvent);
navigator.mediaDevices.getUserMedia(constraintsAux) try {
.then(audioOnlyStream => { const audioOnlyStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
this.clearPermissionDialogTimer(startTime, timeForDialogEvent); this.clearPermissionDialogTimer(startTime, timeForDialogEvent);
mediaStream.addTrack(audioOnlyStream.getAudioTracks()[0]); mediaStream.addTrack(audioOnlyStream.getAudioTracks()[0]);
successCallback(mediaStream); successCallback(mediaStream);
})
.catch(error => { } catch (error) {
this.clearPermissionDialogTimer(startTime, timeForDialogEvent); this.clearPermissionDialogTimer(startTime, timeForDialogEvent);
mediaStream.getAudioTracks().forEach((track) => { mediaStream.getAudioTracks().forEach((track) => {
track.stop(); track.stop();
@ -502,13 +502,13 @@ export class Publisher extends StreamManager {
}); });
errorCallback(this.openvidu.generateAudioDeviceError(error, constraints)); errorCallback(this.openvidu.generateAudioDeviceError(error, constraints));
return; return;
}); }
} else { } else {
successCallback(mediaStream); successCallback(mediaStream);
} }
}; };
const getMediaError = error => { const getMediaError = async (error) => {
logger.error(`getMediaError: ${error.toString()}`); logger.error(`getMediaError: ${error.toString()}`);
this.clearPermissionDialogTimer(startTime, timeForDialogEvent); this.clearPermissionDialogTimer(startTime, timeForDialogEvent);
if (error.name === 'Error') { if (error.name === 'Error') {
@ -518,22 +518,24 @@ export class Publisher extends StreamManager {
let errorName, errorMessage; let errorName, errorMessage;
switch (error.name.toLowerCase()) { switch (error.name.toLowerCase()) {
case 'notfounderror': case 'notfounderror':
navigator.mediaDevices.getUserMedia({ try {
const mediaStream = await navigator.mediaDevices.getUserMedia({
audio: false, audio: false,
video: constraints.video video: constraints.video
}) });
.then(mediaStream => {
mediaStream.getVideoTracks().forEach((track) => { mediaStream.getVideoTracks().forEach((track) => {
track.stop(); track.stop();
}); });
errorName = OpenViduErrorName.INPUT_AUDIO_DEVICE_NOT_FOUND; errorName = OpenViduErrorName.INPUT_AUDIO_DEVICE_NOT_FOUND;
errorMessage = error.toString(); errorMessage = error.toString();
errorCallback(new OpenViduError(errorName, errorMessage)); errorCallback(new OpenViduError(errorName, errorMessage));
}).catch(e => {
} catch (error) {
errorName = OpenViduErrorName.INPUT_VIDEO_DEVICE_NOT_FOUND; errorName = OpenViduErrorName.INPUT_VIDEO_DEVICE_NOT_FOUND;
errorMessage = error.toString(); errorMessage = error.toString();
errorCallback(new OpenViduError(errorName, errorMessage)); errorCallback(new OpenViduError(errorName, errorMessage));
}); }
break; break;
case 'notallowederror': case 'notallowederror':
errorName = this.stream.isSendScreen() ? OpenViduErrorName.SCREEN_CAPTURE_DENIED : OpenViduErrorName.DEVICE_ACCESS_DENIED; errorName = this.stream.isSendScreen() ? OpenViduErrorName.SCREEN_CAPTURE_DENIED : OpenViduErrorName.DEVICE_ACCESS_DENIED;
@ -541,11 +543,12 @@ export class Publisher extends StreamManager {
errorCallback(new OpenViduError(errorName, errorMessage)); errorCallback(new OpenViduError(errorName, errorMessage));
break; break;
case 'overconstrainederror': case 'overconstrainederror':
navigator.mediaDevices.getUserMedia({
try {
const mediaStream = await navigator.mediaDevices.getUserMedia({
audio: false, audio: false,
video: constraints.video video: constraints.video
}) });
.then(mediaStream => {
mediaStream.getVideoTracks().forEach((track) => { mediaStream.getVideoTracks().forEach((track) => {
track.stop(); track.stop();
}); });
@ -557,7 +560,8 @@ export class Publisher extends StreamManager {
errorMessage = "Audio input device doesn't support the value passed for constraint '" + error.constraint + "'"; errorMessage = "Audio input device doesn't support the value passed for constraint '" + error.constraint + "'";
} }
errorCallback(new OpenViduError(errorName, errorMessage)); errorCallback(new OpenViduError(errorName, errorMessage));
}).catch(e => {
} catch (error) {
if (error.constraint.toLowerCase() === 'deviceid') { if (error.constraint.toLowerCase() === 'deviceid') {
errorName = OpenViduErrorName.INPUT_VIDEO_DEVICE_NOT_FOUND; errorName = OpenViduErrorName.INPUT_VIDEO_DEVICE_NOT_FOUND;
errorMessage = "Video input device with deviceId '" + (<ConstrainDOMStringParameters>(<MediaTrackConstraints>constraints.video).deviceId!!).exact + "' not found"; errorMessage = "Video input device with deviceId '" + (<ConstrainDOMStringParameters>(<MediaTrackConstraints>constraints.video).deviceId!!).exact + "' not found";
@ -566,7 +570,8 @@ export class Publisher extends StreamManager {
errorMessage = "Video input device doesn't support the value passed for constraint '" + error.constraint + "'"; errorMessage = "Video input device doesn't support the value passed for constraint '" + error.constraint + "'";
} }
errorCallback(new OpenViduError(errorName, errorMessage)); errorCallback(new OpenViduError(errorName, errorMessage));
}); }
break; break;
case 'aborterror': case 'aborterror':
case 'notreadableerror': case 'notreadableerror':
@ -582,18 +587,14 @@ export class Publisher extends StreamManager {
} }
} }
this.openvidu.generateMediaConstraints(this.properties) try {
.then(myConstraints => { const myConstraints = await this.openvidu.generateMediaConstraints(this.properties);
if (!!myConstraints.videoTrack && !!myConstraints.audioTrack || if (!!myConstraints.videoTrack && !!myConstraints.audioTrack ||
!!myConstraints.audioTrack && myConstraints.constraints?.video === false || !!myConstraints.audioTrack && myConstraints.constraints?.video === false ||
!!myConstraints.videoTrack && myConstraints.constraints?.audio === false) { !!myConstraints.videoTrack && myConstraints.constraints?.audio === false) {
// No need to call getUserMedia at all. MediaStreamTracks already provided // No need to call getUserMedia at all. MediaStreamTracks already provided
successCallback(this.openvidu.addAlreadyProvidedTracks(myConstraints, new MediaStream(), this.stream)); successCallback(this.openvidu.addAlreadyProvidedTracks(myConstraints, new MediaStream(), this.stream));
// Return as we do not need to process further } else {
return;
}
constraints = myConstraints.constraints; constraints = myConstraints.constraints;
const outboundStreamOptions = { const outboundStreamOptions = {
@ -608,31 +609,24 @@ export class Publisher extends StreamManager {
startTime = Date.now(); startTime = Date.now();
this.setPermissionDialogTimer(timeForDialogEvent); this.setPermissionDialogTimer(timeForDialogEvent);
try {
if (this.stream.isSendScreen() && navigator.mediaDevices['getDisplayMedia'] && !platform.isElectron()) { if (this.stream.isSendScreen() && navigator.mediaDevices['getDisplayMedia'] && !platform.isElectron()) {
navigator.mediaDevices['getDisplayMedia']({ video: true }) const mediaStream = await navigator.mediaDevices['getDisplayMedia']({ video: true });
.then(mediaStream => {
this.openvidu.addAlreadyProvidedTracks(myConstraints, mediaStream); this.openvidu.addAlreadyProvidedTracks(myConstraints, mediaStream);
getMediaSuccess(mediaStream, definedAudioConstraint); await getMediaSuccess(mediaStream, definedAudioConstraint);
})
.catch(error => {
getMediaError(error);
});
} else { } else {
this.stream.lastVideoTrackConstraints = constraintsAux.video; this.stream.lastVideoTrackConstraints = constraintsAux.video;
navigator.mediaDevices.getUserMedia(constraintsAux) const mediaStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
.then(mediaStream => {
this.openvidu.addAlreadyProvidedTracks(myConstraints, mediaStream, this.stream); this.openvidu.addAlreadyProvidedTracks(myConstraints, mediaStream, this.stream);
getMediaSuccess(mediaStream, definedAudioConstraint); await getMediaSuccess(mediaStream, definedAudioConstraint);
})
.catch(error => {
getMediaError(error);
});
} }
} catch (error) {
}) await getMediaError(error);
.catch((error: OpenViduError) => { }
}
} catch (error) {
errorCallback(error); errorCallback(error);
}); }
}); });
} }