openvidu-browser 2.27.0 → 2.28.0-beta1

package/src/OpenVidu/OpenVidu.ts

@@ -348,7 +348,9 @@ export class OpenVidu {
             platform.isSafariBrowser() ||
             platform.isAndroidBrowser() || // Android WebView & Ionic apps for Android
             platform.isElectron() ||
-            platform.isNodeJs()
+            platform.isNodeJs() ||
+            // TODO: remove when updating platform detection library
+            platform.isMotorolaEdgeDevice()
         );
     }
 
@@ -512,107 +514,104 @@ export class OpenVidu {
      * });
      * ```
      */
-    getUserMedia(options: PublisherProperties): Promise<MediaStream> {
-        return new Promise<MediaStream>(async (resolve, reject) => {
-            const askForAudioStreamOnly = async (previousMediaStream: MediaStream, constraints: MediaStreamConstraints) => {
-                const definedAudioConstraint = constraints.audio === undefined ? true : constraints.audio;
-                const constraintsAux: MediaStreamConstraints = { audio: definedAudioConstraint, video: false };
-                try {
-                    const audioOnlyStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
-                    previousMediaStream.addTrack(audioOnlyStream.getAudioTracks()[0]);
-                    return resolve(previousMediaStream);
-                } catch (error) {
-                    previousMediaStream.getAudioTracks().forEach((track) => {
-                        track.stop();
-                    });
-                    previousMediaStream.getVideoTracks().forEach((track) => {
-                        track.stop();
-                    });
-                    return reject(this.generateAudioDeviceError(error, constraintsAux));
-                }
-            };
-
+    async getUserMedia(options: PublisherProperties): Promise<MediaStream> {
+        const askForAudioStreamOnly = async (previousMediaStream: MediaStream, constraints: MediaStreamConstraints) => {
+            const definedAudioConstraint = constraints.audio === undefined ? true : constraints.audio;
+            const constraintsAux: MediaStreamConstraints = { audio: definedAudioConstraint, video: false };
             try {
-                const myConstraints = await this.generateMediaConstraints(options);
-                if (
-                    (!!myConstraints.videoTrack && !!myConstraints.audioTrack) ||
-                    (!!myConstraints.audioTrack && myConstraints.constraints?.video === false) ||
-                    (!!myConstraints.videoTrack && myConstraints.constraints?.audio === false)
-                ) {
-                    // No need to call getUserMedia at all. Both tracks provided, or only AUDIO track provided or only VIDEO track provided
-                    return resolve(this.addAlreadyProvidedTracks(myConstraints, new MediaStream()));
-                } else {
-                    // getUserMedia must be called. AUDIO or VIDEO are requesting a new track
+                const audioOnlyStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
+                previousMediaStream.addTrack(audioOnlyStream.getAudioTracks()[0]);
+                return previousMediaStream;
+            } catch (error) {
+                previousMediaStream.getAudioTracks().forEach((track) => {
+                    track.stop();
+                });
+                previousMediaStream.getVideoTracks().forEach((track) => {
+                    track.stop();
+                });
+                throw this.generateAudioDeviceError(error, constraintsAux);
+            }
+        };
 
-                    // Delete already provided constraints for audio or video
-                    if (!!myConstraints.videoTrack) {
-                        delete myConstraints.constraints!.video;
-                    }
-                    if (!!myConstraints.audioTrack) {
-                        delete myConstraints.constraints!.audio;
-                    }
+        try {
+            const myConstraints = await this.generateMediaConstraints(options);
+            if (
+                (!!myConstraints.videoTrack && !!myConstraints.audioTrack) ||
+                (!!myConstraints.audioTrack && myConstraints.constraints?.video === false) ||
+                (!!myConstraints.videoTrack && myConstraints.constraints?.audio === false)
+            ) {
+                // No need to call getUserMedia at all. Both tracks provided, or only AUDIO track provided or only VIDEO track provided
+                return this.addAlreadyProvidedTracks(myConstraints, new MediaStream());
+            } else {
+                // getUserMedia must be called. AUDIO or VIDEO are requesting a new track
 
-                    let mustAskForAudioTrackLater = false;
-                    if (typeof options.videoSource === 'string') {
-                        // Video is deviceId or screen sharing
-                        if (
-                            options.videoSource === 'screen' ||
-                            options.videoSource === 'window' ||
-                            (platform.isElectron() && options.videoSource.startsWith('screen:'))
-                        ) {
-                            // Video is screen sharing
-                            mustAskForAudioTrackLater =
-                                !myConstraints.audioTrack && options.audioSource !== null && options.audioSource !== false;
-                            if (navigator.mediaDevices['getDisplayMedia'] && !platform.isElectron()) {
-                                // getDisplayMedia supported
-                                try {
-                                    const mediaStream = await navigator.mediaDevices['getDisplayMedia']({ video: true });
-                                    this.addAlreadyProvidedTracks(myConstraints, mediaStream);
-                                    if (mustAskForAudioTrackLater) {
-                                        await askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints);
-                                        return;
-                                    } else {
-                                        return resolve(mediaStream);
-                                    }
-                                } catch (error) {
-                                    let errorName: OpenViduErrorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED;
-                                    const errorMessage = error.toString();
-                                    return reject(new OpenViduError(errorName, errorMessage));
+                // Delete already provided constraints for audio or video
+                if (!!myConstraints.videoTrack) {
+                    delete myConstraints.constraints!.video;
+                }
+                if (!!myConstraints.audioTrack) {
+                    delete myConstraints.constraints!.audio;
+                }
+
+                let mustAskForAudioTrackLater = false;
+                if (typeof options.videoSource === 'string') {
+                    // Video is deviceId or screen sharing
+                    if (
+                        options.videoSource === 'screen' ||
+                        options.videoSource === 'window' ||
+                        (platform.isElectron() && options.videoSource.startsWith('screen:'))
+                    ) {
+                        // Video is screen sharing
+                        mustAskForAudioTrackLater =
+                            !myConstraints.audioTrack && options.audioSource !== null && options.audioSource !== false;
+                        if (navigator.mediaDevices['getDisplayMedia'] && !platform.isElectron()) {
+                            // getDisplayMedia supported
+                            try {
+                                const mediaStream = await navigator.mediaDevices['getDisplayMedia']({ video: true });
+                                this.addAlreadyProvidedTracks(myConstraints, mediaStream);
+                                if (mustAskForAudioTrackLater) {
+                                    return await askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints);
+                                } else {
+                                    return mediaStream;
                                 }
-                            } else {
-                                // getDisplayMedia NOT supported. Can perform getUserMedia below with already calculated constraints
+                            } catch (error) {
+                                let errorName: OpenViduErrorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED;
+                                const errorMessage = error.toString();
+                                throw new OpenViduError(errorName, errorMessage);
                             }
                         } else {
-                            // Video is deviceId. Can perform getUserMedia below with already calculated constraints
+                            // getDisplayMedia NOT supported. Can perform getUserMedia below with already calculated constraints
                         }
+                    } else {
+                        // Video is deviceId. Can perform getUserMedia below with already calculated constraints
                     }
-                    // Use already calculated constraints
-                    const constraintsAux = mustAskForAudioTrackLater
-                        ? { video: myConstraints.constraints!.video }
-                        : myConstraints.constraints;
-                    try {
-                        const mediaStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
-                        this.addAlreadyProvidedTracks(myConstraints, mediaStream);
-                        if (mustAskForAudioTrackLater) {
-                            await askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints);
-                        } else {
-                            return resolve(mediaStream);
-                        }
-                    } catch (error) {
-                        let errorName: OpenViduErrorName;
-                        const errorMessage = error.toString();
-                        if (!(options.videoSource === 'screen')) {
-                            errorName = OpenViduErrorName.DEVICE_ACCESS_DENIED;
-                        } else {
-                            errorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED;
-                        }
-                        return reject(new OpenViduError(errorName, errorMessage));
+                }
+                // Use already calculated constraints
+                const constraintsAux = mustAskForAudioTrackLater
+                    ? { video: myConstraints.constraints!.video }
+                    : myConstraints.constraints;
+                try {
+                    const mediaStream = await navigator.mediaDevices.getUserMedia(constraintsAux);
+                    this.addAlreadyProvidedTracks(myConstraints, mediaStream);
+                    if (mustAskForAudioTrackLater) {
+                        return await askForAudioStreamOnly(mediaStream, <MediaStreamConstraints>myConstraints.constraints);
+                    } else {
+                        return mediaStream;
                     }
+                } catch (error) {
+                    let errorName: OpenViduErrorName;
+                    const errorMessage = error.toString();
+                    if (!(options.videoSource === 'screen')) {
+                        errorName = OpenViduErrorName.DEVICE_ACCESS_DENIED;
+                    } else {
+                        errorName = OpenViduErrorName.SCREEN_CAPTURE_DENIED;
+                    }
+                    throw new OpenViduError(errorName, errorMessage);
                 }
-            } catch (error) {
-                reject(error);
             }
-        });
+        } catch (error) {
+            throw error;
+        }
     }
 
     /* tslint:disable:no-empty */
@@ -990,7 +989,7 @@ export class OpenVidu {
     /**
      * @hidden
      */
-    addAlreadyProvidedTracks(myConstraints: CustomMediaStreamConstraints, mediaStream: MediaStream, stream?: Stream) {
+    addAlreadyProvidedTracks(myConstraints: CustomMediaStreamConstraints, mediaStream: MediaStream, stream?: Stream): MediaStream {
         if (!!myConstraints.videoTrack) {
             mediaStream.addTrack(myConstraints.videoTrack);
             if (!!stream) {

package/src/OpenVidu/Session.ts

@@ -992,8 +992,8 @@ export class Session extends EventDispatcher {
                         oldValue = stream.videoActive;
                         event.newValue = event.newValue === 'true';
                         stream.videoActive = event.newValue;
-                        const videoTrack = stream.getMediaStream().getVideoTracks()[0];
-                        if(!videoTrack.enabled && stream.videoActive){
+                        const videoTrack = stream?.getMediaStream()?.getVideoTracks()?.[0];
+                        if(videoTrack && !videoTrack.enabled && stream.videoActive){
                             videoTrack.enabled = true;
                         }
                         break;

package/src/OpenViduInternal/Utils/Platform.ts

@@ -101,6 +101,14 @@ export class PlatformUtils {
         return platform.name === 'Samsung Internet Mobile' || platform.name === 'Samsung Internet';
     }
 
+    // TODO: This method exists to overcome bug https://github.com/bestiejs/platform.js/issues/184
+    /**
+     * @hidden
+     */
+    public isMotorolaEdgeDevice(): boolean {
+        return platform.product?.toLowerCase().includes('motorola edge') || false;
+    }
+
     /**
      * @hidden
      */
@@ -168,10 +176,14 @@ export class PlatformUtils {
             this.isSamsungBrowser() ||
             this.isIonicAndroid() ||
             this.isIonicIos() ||
-            this.isElectron()
+            this.isElectron() ||
+            // TODO: remove when possible
+            this.isMotorolaEdgeDevice()
         );
     }
 
+
+
     /**
      * @hidden
      */

package/static/js/.scannerwork/report-task.txt

@@ -0,0 +1,6 @@
+projectKey=openvidu-browser
+serverUrl=http://172.17.0.1:9000
+serverVersion=10.0.0.68432
+dashboardUrl=http://172.17.0.1:9000/dashboard?id=openvidu-browser
+ceTaskId=AYfrl1uff-k_7mow8Cpd
+ceTaskUrl=http://172.17.0.1:9000/api/ce/task?id=AYfrl1uff-k_7mow8Cpd