senza-sdk 4.2.51-e8275ed.0 → 4.2.51-f4d1f9b.0

package/package.json

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

package/src/remotePlayer.js

@@ -1424,8 +1424,7 @@ class RemotePlayer extends EventTarget {
      * @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 });
@@ -1766,29 +1765,29 @@ class RemotePlayer extends EventTarget {
                     let timerId = 0;
                     const timeBeforeSendingRequest = Date.now();
                     const queryId = window.cefQuery({
-                        request: JSON.stringify({ target: "TC", waitForResponse: true, internalAction: "uiActive", message: JSON.stringify(message) }),
+                        request: JSON.stringify({ target: "TC", waitForResponse: true, message: JSON.stringify(message) }),
                         persistent: false,
                         onSuccess: () => {
                             const duration = Date.now() - timeBeforeSendingRequest;
-                            logger.withFields({ duration }).log(`stop subtitle completed successfully after ${duration} ms`);
+                            logger.withFields({ duration }).log(`stopSubtitle 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}`);
+                            logger.withFields({ duration }).log(`stopSubtitle 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}`);
+                    logger.log(`window.cefQuery for stopSubtitle returned query id ${queryId}`);
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
-                        logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                        logger.log(`stopSubtitle reached timeout of ${timeout} ms, canceling query id ${queryId}`);
                         window.cefQueryCancel(queryId);
-                        reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
+                        reject(new SenzaError(6000, `stopSubtitle reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
                 });
             }
@@ -1804,6 +1803,9 @@ class RemotePlayer extends EventTarget {
                     const logger = sdkLogger.withFields({ FCID });
                     logger.log("remotePlayer play subtitle: sending play action");
                     const configuration = remotePlayer.getConfiguration();
+                    if (!remotePlayer.textTrackVisibility) {
+                        sdkLogger.info("override selected track on _playSubtitle with \"\"");
+                    }
                     const subtitlesLanguage = remotePlayer.textTrackVisibility && (remotePlayer._selectedSubtitlesTrack || configuration.preferredSubtitlesLanguage) || "";
                     let request;
                     const message = {
@@ -1818,7 +1820,6 @@ class RemotePlayer extends EventTarget {
                         request = {
                             target: "TC",
                             waitForResponse: true,
-                            internalAction: "uiExit",
                             message: JSON.stringify(message)
                         };
                     } else {
@@ -1865,13 +1866,12 @@ class RemotePlayer extends EventTarget {
     async _atomicSetSubtitleLanguage() {
         sdkLogger.info("SetSubtitleLanguage: local video element set start while isPLaying=", this._isPlaying);
 
-        this._targetSetSubtitlePlayingState = this._state === lifecycle.UiState.BACKGROUND ? TargetPlayingState.PLAYING_ABR : TargetPlayingState.PAUSED;
+        this._targetSetSubtitlePlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
         this._abortSetSubtitleLanguage = false;
         this._isSetSubtitleByApplication = true;
 
         let state = SetSubtitleLanguageState.INIT;
 
-        let previousPendingSubtitleLanguage = this._pendingSubtitleLanguage;
         let initialSubtitleLanguage = this._pendingSubtitleLanguage;
         let res;
 
@@ -1879,37 +1879,37 @@ class RemotePlayer extends EventTarget {
             try {
                 switch(state) {
                 case SetSubtitleLanguageState.INIT:
-                    state = this._state === lifecycle.UiState.BACKGROUND ? SetSubtitleLanguageState.STOPPED : SetSubtitleLanguageState.SET;
+                    state = SetSubtitleLanguageState.STOPPED; // always stop
                     break;
                 case SetSubtitleLanguageState.STOPPED:
-                    sdkLogger.error("BEFORE STOP BEFORE SET SUBTITLE");
+                    sdkLogger.info("BEFORE STOP BEFORE SET SUBTITLE");
                     await this._stopSubtitle();
-                    sdkLogger.error("AFTER STOP BEFORE SET SUBTITLE");
+                    sdkLogger.info("AFTER STOP BEFORE SET 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");
+                    sdkLogger.log(`remotePlayer _selectTextTrackV3: textTrackId=${textTrackId} isPlaying=${this._isPlaying}`);
+                    res = await this._selectTextTrackV3(initialSubtitleLanguage);
+                    sdkLogger.info("AFTER SET SUBTITLE 1");
+                    state = this._isPlaying ? SetSubtitleLanguageState.PLAYING: SetSubtitleLanguageState.DONE;
+                    break;
+                case SetSubtitleLanguageState.PLAYING:
+                    if (!this._abortSetSubtitleLanguage) {
+                        sdkLogger.info("TARGET PLAYING STATE", this._targetSetSubtitlePlayingState);
+                        sdkLogger.info("BEFORE PLAY AFTER SET SUBTITLE");
+                        this._playSubtitle();
+                    }
                     state = SetSubtitleLanguageState.DONE;
                     break;
                 }
             } catch (error) {
-                sdkLogger.error(`Error during set subtitle process: ${error.message}`);
+                sdkLogger.info(`Error during set subtitle process: ${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) {
-                sdkLogger.error("BEFORE PLAY AFTER SET SUBTITLE 2");
-                this._playSubtitle();
-            }
-        }
         this._isSetSubtitleByApplication = false;
         sdkLogger.info("SetSubtitleLanguage: local video element set subtitle end");
         return res
@@ -1933,31 +1933,33 @@ class RemotePlayer extends EventTarget {
 
                 switch(state) {
                 case SetAudioLanguageState.INIT:
-                    state = this._isPlaying ? SetAudioLanguageState.STOPPED : SetAudioLanguageState.SET;
+                    sdkLogger.info("BEFORE STOP BEFORE SET AUDIO");
+                    await this._stopAudio();
+                    sdkLogger.info("AFTER STOP BEFORE SET AUDIO");
+                    state = 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");
+                    sdkLogger.info("BEFORE PLAY AFTER SET AUDIO 1");
                     state = SetAudioLanguageState.DONE;
                     break;
                 }
             } catch (error) {
-                sdkLogger.error(`Error during set audio process: ${error.message}`);
+                sdkLogger.info(`Error during set audio process: ${error.message}`);
                 state = SetAudioLanguageState.DONE;
                 res = Promise.reject(error);
             }
         }
 
         if (!this._abortSetAudioLanguage) {
-            sdkLogger.error("TARGET PLAYING STATE", this._targetSetAudioPlayingState);
+            sdkLogger.info("TARGET PLAYING STATE", this._targetSetAudioPlayingState);
             if (this._targetSetAudioPlayingState === TargetPlayingState.PLAYING_UI) {
-                sdkLogger.error("BEFORE PLAY AFTER SET AUDIO 2");
+                sdkLogger.info("BEFORE PLAY AFTER SET AUDIO 2");
                 this._play();
             }
         }

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"
 });