senza-sdk 4.2.51-9f586bc.0 → 4.2.51-b73b1af.0

package/package.json

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

package/src/remotePlayer.js

@@ -1067,6 +1067,18 @@ class RemotePlayer extends EventTarget {
             }
         }
 
+        if (this._isSetAudioByApplication) {
+            sdkLogger.info("application requesting play during setAudioLanguage");
+            this._targetSetAudioPlayingState = TargetPlayingState.PLAYING_UI;
+            return Promise.resolve(true);
+        }
+
+        if (this._isSetSubtitleByApplication) {
+            sdkLogger.info("application requesting play during setSubtitleLanguage");
+            this._targetSetSubtitlePlayingState = TargetPlayingState.PLAYING_UI;
+            return Promise.resolve(true);
+        }
+
         // If seeking in progress, wait for seek to complete before playing
         if (this._isSeekingByApplication) {
             sdkLogger.info("application requesting play during seek");
@@ -1106,6 +1118,16 @@ class RemotePlayer extends EventTarget {
             this._targetSeekPlayingState = TargetPlayingState.PAUSED;
             return Promise.resolve(true);
         }
+        if (this._isSetAudioByApplication) {
+            sdkLogger.info("application requesting pause during setAudioLanguage");
+            this._targetSetAudioPlayingState = TargetPlayingState.PAUSED;
+            return Promise.resolve(true);
+        }
+        if (this._isSetSubtitleByApplication) {
+            sdkLogger.info("application requesting pause during setSubtitleLanguage");
+            this._targetSetSubtitlePlayingState = TargetPlayingState.PAUSED;
+            return Promise.resolve(true);
+        }
         return this._pause();
     }
 
@@ -1679,33 +1701,197 @@ 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 _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);
+                });
+            }
+        }
+        
+    }
+
+    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);
+                    }
+                });
+            }
+
+        }
+        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._targetSetSubtitlePlayingState = lifecycle._state === lifecycle.UiState.BACKGROUND ? TargetPlayingState.PLAYING_ABR : TargetPlayingState.PAUSED;
         this._abortSetSubtitleLanguage = false;
         this._isSetSubtitleByApplication = true;
 
         let state = SetSubtitleLanguageState.INIT;
 
         let previousPendingSubtitleLanguage = this._pendingSubtitleLanguage;
-        let initialSubtitleLanguage= this._pendingSubtitleLanguage;
+        let initialSubtitleLanguage = this._pendingSubtitleLanguage;
         let res;
-        
+
         while (!this._abortSetSubtitleLanguage && state !== SetSubtitleLanguageState.DONE) {
             try {
-                // TODO - Implement the logic for setting audio language
                 switch(state) {
                 case SetSubtitleLanguageState.INIT:
-                    state = this._isPlaying ? SetSubtitleLanguageState.STOPPED : SetSubtitleLanguageState.SET;
+                    state = lifecycle._state === lifecycle.UiState.BACKGROUND ? SetSubtitleLanguageState.STOPPED : SetSubtitleLanguageState.SET;
                     break;
                 case SetSubtitleLanguageState.STOPPED:
-                    await lifecycle.moveToForeground();
+                    sdkLogger.error("BEFORE STOP BEFORE SET SUBTITLE");
+                    await this._stopSubtitle();
+                    sdkLogger.error("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");
                     state = SetSubtitleLanguageState.DONE;
                     break;
                 }
@@ -1713,20 +1899,26 @@ class RemotePlayer extends EventTarget {
                 sdkLogger.error(`Error during set subtitle process: ${error.message}`);
                 state = SetSubtitleLanguageState.DONE;
                 res = Promise.reject(error);
-            } finally {
-                if (!this._abortSetSubtitleLanguage) {
-                    this._play();
-                }
-                this._isSetSubtitleByApplication = false;
-                sdkLogger.info("SetSubtitleLanguage: local video element set subtitle end");
             }
         }
+
+        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
     }
 
     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;
 
@@ -1738,19 +1930,20 @@ class RemotePlayer extends EventTarget {
         
         while (!this._abortSetAudioLanguage && state !== SetAudioLanguageState.DONE) {
             try {
-                // TODO - Implement the logic for setting audio language
+
                 switch(state) {
                 case SetAudioLanguageState.INIT:
                     state = this._isPlaying ? SetAudioLanguageState.STOPPED : SetAudioLanguageState.SET;
                     break;
                 case SetAudioLanguageState.STOPPED:
-                    await lifecycle.moveToForeground();
+                    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;
                 }
@@ -1758,14 +1951,19 @@ class RemotePlayer extends EventTarget {
                 sdkLogger.error(`Error during set audio process: ${error.message}`);
                 state = SetAudioLanguageState.DONE;
                 res = Promise.reject(error);
-            } finally {
-                if (!this._abortSetAudioLanguage) {
-                    this._play();
-                }
-                this._isSetAudioByApplication = false;
-                sdkLogger.info("SetAudioLanguage: local video element set audio end");
             }
-        } 
+        }
+
+        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
     }
 }