senza-sdk 4.2.51-6aee9e6.0 → 4.2.51-77d7fb8.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.2.51-6aee9e6.0",
+    "version": "4.2.51-77d7fb8.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",

package/src/remotePlayer.js

@@ -695,7 +695,7 @@ class RemotePlayer extends EventTarget {
         return Promise.resolve(undefined);
     }
 
-    _play() {
+    _play(streamType = StreamType.AUDIO) {
         if (window.cefQuery) {
             const FCID = getFCID();
             const logger = sdkLogger.withFields({ FCID });
@@ -719,7 +719,7 @@ class RemotePlayer extends EventTarget {
             if (this._remotePlayerApiVersion >= 2) {
                 if (this._isAudioSyncEnabled()) {
                     message.switchMode = SwitchMode.SEAMLESS;
-                    message.streamType = StreamType.AUDIO;
+                    message.streamType = streamType;
                     waitForResponse = true;
                 } else {
                     logger.log("remotePlayer play request ignored and will be sent with the lifecycle.moveToBackground()");
@@ -817,6 +817,52 @@ class RemotePlayer extends EventTarget {
         return Promise.resolve(undefined);
     }
 
+    _stop(streamType = StreamType.AUDIO) {
+        if (window.cefQuery) {
+            this._changePlayMode(false);
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            logger.log(`remotePlayer stop: sending stop action for streamType ${streamType}`);
+            const message = {
+                type: "remotePlayer.stop",
+                class: "remotePlayer",
+                action: "stop",
+                streamType: streamType,
+                fcid: FCID
+            };
+            const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
+            return new Promise((resolve, reject) => {
+                let timerId = 0;
+                const timeBeforeSendingRequest = Date.now();
+                const queryId = window.cefQuery({
+                    request: JSON.stringify(request),
+                    persistent: false,
+                    onSuccess: () => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`stop completed successfully after ${duration} ms`);
+                        timerId = clearTimer(timerId);
+                        resolve();
+                    },
+                    onFailure: (code, msg) => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`stop failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                        timerId = clearTimer(timerId);
+                        reject(new RemotePlayerError(code, msg));
+                    }
+                });
+                logger.log(`window.cefQuery for stop returned query id ${queryId}`);
+                const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                timerId = setTimeout(() => {
+                    logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new RemotePlayerError(6000, `stop reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+        sdkLogger.error("remotePlayer play: window.cefQuery is undefined");
+        return Promise.resolve(undefined);
+    }
+
     /** In order to support a seamless switch between the video in the UI and ABR, the web application must
      * register the video element being used for the currently played video before calling the load and play apis.
      * @param {object} video The video element currently playing video in the web application
@@ -1235,8 +1281,7 @@ class RemotePlayer extends EventTarget {
         case 2:
             return this._selectAudioTrackV2(audioTrackId, prevSelectedAudioTrack);
         default:
-            this._pendingAudioLanguage = audioTrackId;
-            return this._atomicSetAudioLanguage();
+            return this._atomicSetAudioLanguage(audioTrackId, prevSelectedAudioTrack);
         }
     }
 
@@ -1283,11 +1328,10 @@ class RemotePlayer extends EventTarget {
      * Available only from v3 and on
      *
      * @param {string} audioTrackId - The ID of the audio track to select.
-     * @param {string} prevSelectedAudioTrack - The previously selected audio track ID.
      * @returns {Promise<void>} Resolves when the operation is complete.
      * */
-    async _selectAudioTrackV3(audioTrackId, prevSelectedAudioTrack) {
-        sdkLogger.log(`remotePlayer _selectAudioTrackV3: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying}`);
+    async _selectAudioTrackV3(audioTrackId) {
+        sdkLogger.log(`remotePlayer _selectAudioTrackV3: audioTrackId=${audioTrackId} isPlaying=${this._isPlaying}`);
         if (window.cefQuery) {
             const FCID = getFCID();
             const logger = sdkLogger.withFields({ FCID });
@@ -1373,8 +1417,7 @@ class RemotePlayer extends EventTarget {
         case 2:
             return this._selectTextTrackV2(textTrackId, prevSelectedTextTrack);
         default:
-            this._pendingSubtitleLanguage = textTrackId;
-            return this._atomicSetSubtitleLanguage();
+            return this._atomicSetSubtitleLanguage(textTrackId, prevSelectedTextTrack);
         }
     }
 
@@ -1421,11 +1464,9 @@ class RemotePlayer extends EventTarget {
      * Available only from v3 and on
      *
      * @param {string} textTrackId - The ID of the text track to select.
-     * @param {string} prevSelectedTextTrack - The previously selected text track ID.
      * @returns {Promise<void>} Resolves when the operation is complete.
      * */
-    async _selectTextTrackV3(textTrackId, prevSelectedTextTrack) {
-        sdkLogger.log(`remotePlayer _selectTextTrackV3: prevAudioTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying}`);
+    async _selectTextTrackV3(textTrackId) {
         if (window.cefQuery) {
             const FCID = getFCID();
             const logger = sdkLogger.withFields({ FCID });
@@ -1435,7 +1476,7 @@ class RemotePlayer extends EventTarget {
                 class: "remotePlayer",
                 action: "setSubtitleLanguage",
                 fcid: FCID,
-                language: textTrackId,
+                language: textTrackId
             };
             const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
             return new Promise((resolve, reject) => {
@@ -1701,271 +1742,101 @@ class RemotePlayer extends EventTarget {
         sdkLogger.info("Seeking: local video element seeking end");
     }
 
-    async _stopAudio() {
-        if (window.cefQuery) {
-            if (this._remotePlayerApiVersion >= 2) {
-                return new Promise((resolve, reject) => {
-                    const FCID = getFCID();
-                    const logger = sdkLogger.withFields({ FCID });
-                    logger.log(`remotePlayer _stopAudio: sending stop action remotePlayer._isPlaying=${remotePlayer._isPlaying}`);
-                    const message = {
-                        type: "remotePlayer.stop",
-                        class: "remotePlayer",
-                        action: "stop",
-                        streamType: StreamType.AUDIO,
-                        fcid: FCID
-                    };
-                    let timerId = 0;
-                    const timeBeforeSendingRequest = Date.now();
-                    const queryId = window.cefQuery({
-                        request: JSON.stringify({ target: "TC", waitForResponse: true, internalAction: "uiActive", message: JSON.stringify(message) }),
-                        persistent: false,
-                        onSuccess: () => {
-                            const duration = Date.now() - timeBeforeSendingRequest;
-                            logger.withFields({ duration }).log(`stop audio completed successfully after ${duration} ms`);
-                            this._inTransition = false;
-                            timerId = clearTimer(timerId);
-                            resolve(true);
-                        },
-                        onFailure: (code, msg) => {
-                            const duration = Date.now() - timeBeforeSendingRequest;
-                            logger.withFields({ duration }).log(`stop audio failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                            this._inTransition = false;
-                            timerId = clearTimer(timerId);
-                            reject(new SenzaError(code, msg));
-                        }
-                    });
-                    logger.log(`window.cefQuery for stop audio returned query id ${queryId}`);
-                    const timeout = this._remotePlayerConfirmationTimeout + 1000;
-                    timerId = setTimeout(() => {
-                        logger.log(`stop audio reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransition = false;
-                        window.cefQueryCancel(queryId);
-                        reject(new SenzaError(6000, `stop audio reached timeout of ${timeout} ms`));
-                    }, timeout, queryId);
-                });
-            }
-        }
+    async _atomicSetAudioLanguage(audioTrackId, prevSelectedAudioTrack) {
+        this._targetSetAudioPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
 
-    }
+        sdkLogger.log(`remotePlayer _atomicSetAudioLanguage: prevAudioTrack=${prevSelectedAudioTrack} audioTrackId=${audioTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetAudioPlayingState}`);
 
-    async _stopSubtitle() {
-        if (window.cefQuery) {
-            if (this._remotePlayerApiVersion >= 2) {
-                return new Promise((resolve, reject) => {
-                    const FCID = getFCID();
-                    const logger = sdkLogger.withFields({ FCID });
-                    logger.log(`remotePlayer _stopSubtitle: sending stop action remotePlayer._isPlaying=${remotePlayer._isPlaying}`);
-                    const message = {
-                        type: "remotePlayer.stop",
-                        class: "remotePlayer",
-                        action: "stop",
-                        streamType: StreamType.SUBTITLE,
-                        fcid: FCID
-                    };
-                    let timerId = 0;
-                    const timeBeforeSendingRequest = Date.now();
-                    const queryId = window.cefQuery({
-                        request: JSON.stringify({ target: "TC", waitForResponse: true, internalAction: "uiActive", message: JSON.stringify(message) }),
-                        persistent: false,
-                        onSuccess: () => {
-                            const duration = Date.now() - timeBeforeSendingRequest;
-                            logger.withFields({ duration }).log(`stop subtitle completed successfully after ${duration} ms`);
-                            this._inTransition = false;
-                            timerId = clearTimer(timerId);
-                            resolve(true);
-                        },
-                        onFailure: (code, msg) => {
-                            const duration = Date.now() - timeBeforeSendingRequest;
-                            logger.withFields({ duration }).log(`stop subtitle failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                            this._inTransition = false;
-                            timerId = clearTimer(timerId);
-                            reject(new SenzaError(code, msg));
-                        }
-                    });
-                    logger.log(`window.cefQuery for stop returned query id ${queryId}`);
-                    const timeout = this._remotePlayerConfirmationTimeout + 1000;
-                    timerId = setTimeout(() => {
-                        logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        window.cefQueryCancel(queryId);
-                        reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
-                    }, timeout, queryId);
-                });
-            }
-        }
-        
-    }
+        this._abortSetAudioLanguage = false;
+        this._isSetAudioByApplication = true;
 
-    async _playSubtitle() {
-        if (window.cefQuery) {
-            if (this._remotePlayerApiVersion >= 2) {
-                return new Promise((resolve, reject) => {
-                    const FCID = getFCID();
-                    const logger = sdkLogger.withFields({ FCID });
-                    logger.log("remotePlayer play subtitle: sending play action");
-                    const configuration = remotePlayer.getConfiguration();
-                    const subtitlesLanguage = remotePlayer.textTrackVisibility && (remotePlayer._selectedSubtitlesTrack || configuration.preferredSubtitlesLanguage) || "";
-                    let request;
-                    const message = {
-                        action: "play",
-                        fcid: FCID,
-                        subtitlesLanguage
-                    };
-                    if (this._remotePlayerApiVersion >= 2) {
-                        message.type = "remotePlayer.play";
-                        message.class = "remotePlayer";
-                        message.streamType = StreamType.SUBTITLE;
-                        request = {
-                            target: "TC",
-                            waitForResponse: true,
-                            internalAction: "uiExit",
-                            message: JSON.stringify(message)
-                        };
-                    } else {
-                        request = message;
-                    }
-                    let timerId = 0;
-                    const timeBeforeSendingRequest = Date.now();
-                    const queryId = window.cefQuery({
-                        request: JSON.stringify(request),
-                        persistent: false,
-                        onSuccess: () => {
-                            const duration = Date.now() - timeBeforeSendingRequest;
-                            logger.withFields({ duration }).log(`play subtitle completed successfully after ${duration} ms`);
-                            this._inTransition = false;
-                            timerId = clearTimer(timerId);
-                            resolve();
-                        },
-                        onFailure: (code, msg) => {
-                            const duration = Date.now() - timeBeforeSendingRequest;
-                            logger.withFields({ duration }).log(`play subtitle failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                            this._inTransition = false;
-                            timerId = clearTimer(timerId);
-                            reject(new SenzaError(code, msg));
-                        }
-                    });
-                    if (this._remotePlayerApiVersion >= 2) {
-                        logger.log(`window.cefQuery for play subtitle returned query id ${queryId}`);
-                        const timeout = this._remotePlayerConfirmationTimeout + 1000;
-                        timerId = setTimeout(() => {
-                            logger.log(`play subtitle reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                            this._inTransition = false;
-                            window.cefQueryCancel(queryId);
-                            reject(new SenzaError(6000, `play subtitle reached timeout of ${timeout} ms`));
-                        }, timeout, queryId);
+        let state = SetAudioLanguageState.INIT;
+        let res;
+
+        while (!this._abortSetAudioLanguage && state !== SetAudioLanguageState.DONE) {
+            try {
+                switch(state) {
+                case SetAudioLanguageState.INIT:
+                    // always stop stream before changing language to flush current segments
+                    // because we cannot differentiate if player is paused/stopped
+                    state = SetAudioLanguageState.STOPPED;
+                    break;
+                case SetAudioLanguageState.STOPPED:
+                    await this._stop(StreamType.AUDIO);
+                    state = SetAudioLanguageState.SET;
+                    break;
+                case SetAudioLanguageState.SET:
+                    res = await this._selectAudioTrackV3(audioTrackId);
+                    // check if we need to resume playback or leave player state as is
+                    state = this._targetSetAudioPlayingState !== TargetPlayingState.PAUSED ? SetAudioLanguageState.PLAYING: SetAudioLanguageState.DONE;
+                    sdkLogger.log(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetAudioPlayingState}`);
+                    break;
+                case SetAudioLanguageState.PLAYING:
+                    if (!this._abortSetAudioLanguage) {
+                        await this._play(StreamType.AUDIO);
                     }
-                });
+                    state = SetAudioLanguageState.DONE;
+                    break;
+                }
+            } catch (error) {
+                sdkLogger.error(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} failed with error ${error.message}.`);
+                state = SetAudioLanguageState.DONE;
+                res = Promise.reject(error);
             }
-
         }
-        sdkLogger.error("remotePlayer play subtitle: window.cefQuery is undefined");
-        return Promise.resolve(undefined);
-    }
 
-    async _atomicSetSubtitleLanguage() {
-        sdkLogger.info("SetSubtitleLanguage: local video element set start while isPLaying=", this._isPlaying);
+        this._isSetAudioByApplication = false;
+        sdkLogger.log(`remotePlayer _atomicSetAudioLanguage: audioTrackId=${audioTrackId} ended.`);
+        return res;
+    }
 
+    async _atomicSetSubtitleLanguage(textTrackId, prevSelectedTextTrack) {
         this._targetSetSubtitlePlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
+        sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: prevTextTrack=${prevSelectedTextTrack} textTrackId=${textTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetSubtitlePlayingState}`);
+
         this._abortSetSubtitleLanguage = false;
         this._isSetSubtitleByApplication = true;
 
         let state = SetSubtitleLanguageState.INIT;
-
-        let previousPendingSubtitleLanguage = this._pendingSubtitleLanguage;
-        let initialSubtitleLanguage = this._pendingSubtitleLanguage;
         let res;
 
         while (!this._abortSetSubtitleLanguage && state !== SetSubtitleLanguageState.DONE) {
             try {
                 switch(state) {
                 case SetSubtitleLanguageState.INIT:
-                    state = this._isPlaying ? SetSubtitleLanguageState.STOPPED : SetSubtitleLanguageState.SET;
+                    // always stop stream before changing language to flush current segments
+                    // because we cannot differentiate if player is paused/stopped
+                    state = SetSubtitleLanguageState.STOPPED;
                     break;
                 case SetSubtitleLanguageState.STOPPED:
-                    sdkLogger.error("BEFORE STOP BEFORE SET SUBTITLE");
-                    await this._stopSubtitle();
-                    sdkLogger.error("AFTER STOP BEFORE SET SUBTITLE");
+                    await this._stop(StreamType.SUBTITLE);
                     state = SetSubtitleLanguageState.SET;
                     break;
                 case SetSubtitleLanguageState.SET:
-                    initialSubtitleLanguage = this._pendingSubtitleLanguage;
-                    previousPendingSubtitleLanguage = this._selectedSubtitleTrack;
-                    res = await this._selectTextTrackV3(initialSubtitleLanguage, previousPendingSubtitleLanguage);
-                    sdkLogger.error("BEFORE PLAY AFTER SET SUBTITLE 1");
+                    res = await this._selectTextTrackV3(textTrackId);
+                    // check if we need to resume playback or leave player state as is
+                    state = this._targetSetSubtitlePlayingState !== TargetPlayingState.PAUSED ? SetSubtitleLanguageState.PLAYING: SetSubtitleLanguageState.DONE;
+                    sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} isPlaying=${this._isPlaying} targetState=${this._targetSetSubtitlePlayingState}`);
+                    break;
+                case SetSubtitleLanguageState.PLAYING:
+                    if (!this._abortSetSubtitleLanguage) {
+                        await this._play(StreamType.SUBTITLE | StreamType.AUDIO);
+                    }
                     state = SetSubtitleLanguageState.DONE;
                     break;
                 }
             } catch (error) {
-                sdkLogger.error(`Error during set subtitle process: ${error.message}`);
+                sdkLogger.error(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} failed with error ${error.message}.`);
                 state = SetSubtitleLanguageState.DONE;
                 res = Promise.reject(error);
             }
         }
 
-        if (!this._abortSetSubtitleLanguage) {
-            sdkLogger.error("TARGET PLAYING STATE", this._targetSetSubtitlePlayingState);
-            sdkLogger.error("TEXT TRACK VISIBILITY", this._textTrackVisibility);
-            if (this._targetSetSubtitlePlayingState === TargetPlayingState.PLAYING_ABR && this._textTrackVisibility) {
-                sdkLogger.error("BEFORE PLAY AFTER SET SUBTITLE 2");
-                this._playSubtitle();
-            }
-        }
         this._isSetSubtitleByApplication = false;
-        sdkLogger.info("SetSubtitleLanguage: local video element set subtitle end");
-        return res
+        sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} ended.`);
+        return res;
     }
 
-    async _atomicSetAudioLanguage() {
-        sdkLogger.info("SetAudioLanguage: local video element set start while isPLaying=", this._isPlaying);
-
-        this._targetSetAudioPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
-        this._abortSetAudioLanguage = false;
-        this._isSetAudioByApplication = true;
-
-        let state = SetAudioLanguageState.INIT;
-
-        let previousPendingAudioLanguage = this._pendingAudioLanguage;
-        let initialAudioLanguage= this._pendingAudioLanguage;
-        let res;
-        
-        while (!this._abortSetAudioLanguage && state !== SetAudioLanguageState.DONE) {
-            try {
-
-                switch(state) {
-                case SetAudioLanguageState.INIT:
-                    state = this._isPlaying ? SetAudioLanguageState.STOPPED : SetAudioLanguageState.SET;
-                    break;
-                case SetAudioLanguageState.STOPPED:
-                    await this._stopAudio();
-                    state = SetAudioLanguageState.SET;
-                    break;
-                case SetAudioLanguageState.SET:
-                    initialAudioLanguage = this._pendingAudioLanguage;
-                    previousPendingAudioLanguage = this._selectedAudioTrack;
-                    res = await this._selectAudioTrackV3(initialAudioLanguage, previousPendingAudioLanguage);
-                    sdkLogger.error("BEFORE PLAY AFTER SET AUDIO 1");
-                    state = SetAudioLanguageState.DONE;
-                    break;
-                }
-            } catch (error) {
-                sdkLogger.error(`Error during set audio process: ${error.message}`);
-                state = SetAudioLanguageState.DONE;
-                res = Promise.reject(error);
-            }
-        }
-
-        if (!this._abortSetAudioLanguage) {
-            sdkLogger.error("TARGET PLAYING STATE", this._targetSetAudioPlayingState);
-            if (this._targetSetAudioPlayingState === TargetPlayingState.PLAYING_UI) {
-                sdkLogger.error("BEFORE PLAY AFTER SET AUDIO 2");
-                this._play();
-            }
-        }
-
-        this._isSetAudioByApplication = false;
-        sdkLogger.info("SetAudioLanguage: local video element set audio end");
-        return res
-    }
 }
 /**
  *

package/src/utils.js

@@ -159,8 +159,7 @@ export const SetAudioLanguageState = Object.freeze({
     INIT: "init",
     STOPPED: "stopped",
     SET: "set",
-    MULTI_SET: "multiSet",
-    WAITING: "waiting",
+    PLAYING: "playing",
     DONE: "done"
 });
 
@@ -168,8 +167,7 @@ export const SetSubtitleLanguageState = Object.freeze({
     INIT: "init",
     STOPPED: "stopped",
     SET: "set",
-    MULTI_SET: "multiSet",
-    WAITING: "waiting",
+    PLAYING: "playing",
     DONE: "done"
 });