senza-sdk 4.3.2-f445d5d.0 → 4.3.3-13bd44c.0

package/src/implementation/remotePlayer.js

@@ -140,13 +140,76 @@ class RemotePlayer extends RemotePlayerInterface {
          * @private
          */
         this._isPlaying = false;
+    }
 
-        /**
-         * @type {string}
-         * @description the last set blackout time as epoch seconds.
-         * @private
-         */
-        this._blackoutTime = 0;
+    /** @private Initialize the remote player
+     * @param {Object} uiStreamerSettings ui-streamer portion of the settings taken from session info
+     * */
+    async _init(uiStreamerSettings, triggerEvent) {
+        sdkLogger.info("Initializing RemotePlayer");
+        let playerState = {
+            isLoaded: false,
+            playbackUrl: ""
+        };
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            const message = {
+                type: "playerState",
+                fcid: FCID
+            };
+            const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
+            try {
+                const playerStateStr = await new Promise((resolve, reject) => {
+                    window.cefQuery({
+                        request: JSON.stringify(request),
+                        persistent: false,
+                        onSuccess: (playerState) => {
+                            logger.log("playerState request successfully returned", playerState);
+                            resolve(playerState);
+                        },
+                        onFailure: (code, msg) => {
+                            logger.error(`playerState request failed: ${code} ${msg}`);
+                            reject();
+                        }
+                    });
+                });
+                playerState = JSON.parse(playerStateStr);
+            } catch {
+                logger.error("either failed to get or failed to parse player state");
+            }
+        }
+        this._loadMode = playerState?.isLoaded ? this.LoadMode.LOADED : this.LoadMode.NOT_LOADED;
+
+        this._isPlaying = window?.sessionStorage?.getItem("senzaSdk_isPlaying") === "true";
+
+        sdkLogger.info(`RemotePlayer initialized with load mode: ${this._loadMode}, senzaSdk_isPlaying: ${this._isPlaying}`);
+        this._loadedUrl = playerState?.playbackUrl || "";
+        // Make sure that the event listeners are registered only once
+        if (!this._isInitialized) {
+            this._addSenzaEventListeners();
+        }
+        this._isInitialized = true;
+        this._remotePlayerConfirmationTimeout = uiStreamerSettings?.remotePlayerConfirmationTimeout ?? DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT;
+        this._remotePlayerApiVersion = uiStreamerSettings?.remotePlayerApiVersion || 1;
+        this._multiSeekDelay = uiStreamerSettings?.multiSeekDelay || MULTI_SEEK_DELAY_MSEC;
+
+        sdkLogger.info(`remotePLayer isPlaying=${this._isPlaying}`);
+
+        let playbackMetadata = {};
+        try {
+            playbackMetadata = JSON.parse(triggerEvent?.playbackMetadata || "{}");
+        } catch (e) {
+            sdkLogger.error(`failed to parse playbackMetadata: ${e.message}`);
+        }
+        this._availabilityStartTime = playbackMetadata.availabilityStartTime;
+        this._updateTracks(playbackMetadata);
+    }
+
+    /**
+     * @private Add event listeners for system events
+     */
+    _addSenzaEventListeners() {
 
         typeof document !== "undefined" && document.addEventListener("hs/remotePlayerEvent", (e) => {
             sdkLogger.info("Got hs/remotePlayerEvent event with detail", JSON.stringify(e?.detail));
@@ -230,65 +293,7 @@ class RemotePlayer extends RemotePlayerInterface {
             };
             this.dispatchEvent(licenseRequestEvent);
         });
-    }
-
-    /** @private Initialize the remote player
-     * @param {Object} uiStreamerSettings ui-streamer portion of the settings taken from session info
-     * */
-    async _init(uiStreamerSettings, triggerEvent) {
-        let playerState = {
-            isLoaded: false,
-            playbackUrl: ""
-        };
-        if (window.cefQuery) {
-            const FCID = getFCID();
-            const logger = sdkLogger.withFields({ FCID });
-            const message = {
-                type: "playerState",
-                fcid: FCID
-            };
-            const request = { target: "UI-Streamer", waitForResponse: false, message: JSON.stringify(message) };
-            try {
-                const playerStateStr = await new Promise((resolve, reject) => {
-                    window.cefQuery({
-                        request: JSON.stringify(request),
-                        persistent: false,
-                        onSuccess: (playerState) => {
-                            logger.log("playerState request successfully returned", playerState);
-                            resolve(playerState);
-                        },
-                        onFailure: (code, msg) => {
-                            logger.error(`playerState request failed: ${code} ${msg}`);
-                            reject();
-                        }
-                    });
-                });
-                playerState = JSON.parse(playerStateStr);
-            } catch {
-                logger.error("either failed to get or failed to parse player state");
-            }
-        }
-        this._loadMode = playerState?.isLoaded ? this.LoadMode.LOADED : this.LoadMode.NOT_LOADED;
-
-        this._isPlaying = window?.sessionStorage?.getItem("senzaSdk_isPlaying") === "true";
-
-        sdkLogger.info(`RemotePlayer initialized with load mode: ${this._loadMode}, senzaSdk_isPlaying: ${this._isPlaying}`);
-        this._loadedUrl = playerState?.playbackUrl || "";
-        this._isInitialized = true;
-        this._remotePlayerConfirmationTimeout = uiStreamerSettings?.remotePlayerConfirmationTimeout ?? DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT;
-        this._remotePlayerApiVersion = uiStreamerSettings?.remotePlayerApiVersion || 1;
-        this._multiSeekDelay = uiStreamerSettings?.multiSeekDelay || MULTI_SEEK_DELAY_MSEC;
-
-        sdkLogger.info(`remotePLayer isPlaying=${this._isPlaying}`);
-
-        let playbackMetadata = {};
-        try {
-            playbackMetadata = JSON.parse(triggerEvent?.playbackMetadata || "{}");
-        } catch (e) {
-            sdkLogger.error(`failed to parse playbackMetadata: ${e.message}`);
-        }
-        this._availabilityStartTime = playbackMetadata.availabilityStartTime;
-        this._updateTracks(playbackMetadata);
+        sdkLogger.log("[RemotePlayer] Added event listeners for system events");
     }
 
     /** @private update audio and text tracks
@@ -751,7 +756,6 @@ class RemotePlayer extends RemotePlayerInterface {
             this._abortSetAudioLanguage = true;
             this._abortSetSubtitleLanguage = true;
             this._abortSeeking = true;
-            this._blackoutTime = 0;
             if (reset) {
                 this._reset();
             }
@@ -1363,14 +1367,23 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
-    setBlackoutTime(date) {
+    /**
+     * The function sets a blackout time for the screen.
+     * The blackout time is the time when the screen will be blacked out.
+     * This is useful for parental controls where the screen should be blacked out during certain times
+     *
+     * @param {Date} date
+     * @returns {Promise<void>} A Promise that resolves once the blackout time is set.
+     * @throws {RemotePlayerError} If the player is not initialized or not loaded. if date is not a Date object or if the remote player api version is not supported
+     */
+    setScreenBlackout(date) {
 
         if (!this._isInitialized) {
-            throw new RemotePlayerError(6500, "Cannot call setBlackoutTime() if remote player is not initialized");
+            throw new RemotePlayerError(6500, "Cannot call setScreenBlackout() if remote player is not initialized");
         }
 
         if (this._loadMode !== this.LoadMode.LOADED) {
-            throw new RemotePlayerError(6001, "Cannot call setBlackoutTime() if player is not loaded");
+            throw new RemotePlayerError(6001, "Cannot call setScreenBlackout() if player is not loaded");
         }
 
         if (!(date instanceof Date)) {
@@ -1378,112 +1391,35 @@ class RemotePlayer extends RemotePlayerInterface {
         }
 
         if (this._remotePlayerApiVersion < 2) {
-            throw new RemotePlayerError(6504, `setBlackoutTime is not supported in remotePlayerApiVersion=${this._remotePlayerApiVersion}. remotePlayerApiVersion >= 2 required`);
+            throw new RemotePlayerError(6504, "setScreenBlackout(): internal error");
         }
 
         const blackoutTime = (date.getTime()/1000).toFixed(2);
-        if (window.cefQuery) {
-            const FCID = getFCID();
-            const logger = sdkLogger.withFields({ FCID });
-            logger.log("remotePlayer setBlackoutTime: sending screenBlackout action");
-            const message = {
-                type: "remotePlayer.screenBlackout",
-                class: "remotePlayer",
-                action: "screenBlackout",
-                fcid: FCID,
-                blackoutTime
-            };
-            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: () => {
-                        this._blackoutTime = blackoutTime;
-                        const duration = Date.now() - timeBeforeSendingRequest;
-                        logger.withFields({ duration }).log(`setBlackoutTime completed successfully after ${duration} ms`);
-                        timerId = clearTimer(timerId);
-                        resolve();
-                    },
-                    onFailure: (code, msg) => {
-                        const duration = Date.now() - timeBeforeSendingRequest;
-                        logger.withFields({ duration }).log(`setBlackoutTime failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                        timerId = clearTimer(timerId);
-                        reject(new RemotePlayerError(code, msg));
-                    }
-                });
-
-                logger.log(`window.cefQuery for setBlackoutTime returned query id ${queryId}`);
-                const timeout = this._remotePlayerConfirmationTimeout + 1000;
-                timerId = setTimeout(() => {
-                    logger.log(`setBlackoutTime reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                    window.cefQueryCancel(queryId);
-                    reject(new RemotePlayerError(6000, `setBlackoutTime reached timeout of ${timeout} ms`));
-                }, timeout, queryId);
-            });
-        }
-        sdkLogger.error("remotePlayer setBlackoutTime: window.cefQuery is undefined");
-        return Promise.resolve(undefined);
+        sdkLogger.info(`remotePlayer.setScreenBlackout(): setting blackout time to ${blackoutTime}`);
+        return this._setScreenBlackout(blackoutTime);
     }
 
-    resetBlackoutTime() {
+    /**
+     * The function resets the currently set blackout time for the screen.
+     * This is useful for parental controls to be reset the blackout time after it has been set.
+     *
+     * @returns {Promise<void>} A Promise that resolves once the blackout time is reset.
+     * @throws {RemotePlayerError} If the player is not initialized or not loaded. if the remote player api version is not supported
+     */
+    resetScreenBlackout() {
         if (!this._isInitialized) {
-            throw new RemotePlayerError(6500, "Cannot call resetBlackoutTime() if remote player is not initialized");
+            throw new RemotePlayerError(6500, "Cannot call resetScreenBlackout() if remote player is not initialized");
         }
 
         if (this._loadMode !== this.LoadMode.LOADED) {
-            throw new RemotePlayerError(6001, "Cannot call resetBlackoutTime() if player is not loaded");
+            throw new RemotePlayerError(6001, "Cannot call resetScreenBlackout() if player is not loaded");
         }
 
         if (this._remotePlayerApiVersion < 2) {
-            throw new RemotePlayerError(6504, `resetBlackoutTime is not supported in remotePlayerApiVersion=${this._remotePlayerApiVersion}. remotePlayerApiVersion >= 2 required`);
+            throw new RemotePlayerError(6504, "resetScreenBlackout(): internal error");
         }
-
-        if (window.cefQuery) {
-            const FCID = getFCID();
-            const logger = sdkLogger.withFields({ FCID });
-            logger.log("remotePlayer resetBlackoutTime: sending screenBlackout action");
-            const message = {
-                type: "remotePlayer.screenBlackout",
-                class: "remotePlayer",
-                action: "screenBlackout",
-                fcid: FCID,
-                blackoutTime: 0 // Resetting the blackout time
-            };
-            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: () => {
-                        this._blackoutTime = 0; // Resetting the blackout time
-                        const duration = Date.now() - timeBeforeSendingRequest;
-                        logger.withFields({ duration }).log(`resetBlackoutTime completed successfully after ${duration} ms`);
-                        timerId = clearTimer(timerId);
-                        resolve();
-                    },
-                    onFailure: (code, msg) => {
-                        const duration = Date.now() - timeBeforeSendingRequest;
-                        logger.withFields({ duration }).log(`resetBlackoutTime failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                        timerId = clearTimer(timerId);
-                        reject(new RemotePlayerError(code, msg));
-                    }
-                });
-                logger.log(`window.cefQuery for resetBlackoutTime returned query id ${queryId}`);
-                const timeout = this._remotePlayerConfirmationTimeout + 1000;
-                timerId = setTimeout(() => {
-                    logger.log(`resetBlackoutTime reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                    window.cefQueryCancel(queryId);
-                    reject(new RemotePlayerError(6000, `resetBlackoutTime reached timeout of ${timeout} ms`));
-                }, timeout, queryId);
-            });
-        }
-        sdkLogger.error("remotePlayer resetBlackoutTime: window.cefQuery is undefined");
-        return Promise.resolve(undefined);
+        sdkLogger.info("remotePlayer.resetScreenBlackout(): resetting blackout time");
+        return this._setScreenBlackout(0);
     }
 
     /**
@@ -1837,6 +1773,52 @@ class RemotePlayer extends RemotePlayerInterface {
         sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} ended.`);
         return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
     }
+
+    _setScreenBlackout(blackoutTime) {
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            logger.log(`sending screenBlackout action at ${blackoutTime}`);
+            const message = {
+                type: "remotePlayer.screenBlackout",
+                class: "remotePlayer",
+                action: "screenBlackout",
+                fcid: FCID,
+                blackoutTime
+            };
+            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(`setBlackoutTime completed successfully after ${duration} ms`);
+                        timerId = clearTimer(timerId);
+                        resolve();
+                    },
+                    onFailure: (code, msg) => {
+                        const duration = Date.now() - timeBeforeSendingRequest;
+                        logger.withFields({ duration }).log(`setBlackoutTime failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
+                        timerId = clearTimer(timerId);
+                        reject(new RemotePlayerError(code, msg));
+                    }
+                });
+
+                logger.log(`window.cefQuery for screenBlackout returned query id ${queryId}`);
+                const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                timerId = setTimeout(() => {
+                    logger.log(`screenBlackout reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new RemotePlayerError(6000, `screenBlackout reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+        sdkLogger.error("screenBlackout: window.cefQuery is undefined");
+        return Promise.resolve(undefined);
+    }
 }
 /**
  *

package/src/interface/alarmManager.js

@@ -1,4 +1,4 @@
-import { noop } from "./utils";
+import { noop } from "./utils.js";
 
 /**
  * alarm event

package/src/interface/remotePlayer.js

@@ -117,7 +117,7 @@ export class RemotePlayerError extends Error {
  * | 6501      | Player            | load() was called while previous load/unload was still in progress                              |
  * | 6502      | Player            | unload() was called while previous unload/load was still in progress                            |
  * | 6503      | Player            | The remote player api call has invalid parameters                                               |
- * | 6504      | Player            | The remote player api call has invalid api version                                              |
+ * | 6504      | Player            | The remote player api internal error                                                            |
  * | 8001      | Player            | Error pulling manifest. bad parameters                                                          |
  * | 8002      | Player            | Error pulling manifest. filters returned no data                                                |
  * | 8003      | Player            | Error pulling manifest. fetch error                                                             |
@@ -400,22 +400,27 @@ class RemotePlayer extends EventTarget {
     }
 
     /**
-     *
+     * The function sets a blackout time for the screen.
+     * The blackout time is the time when the screen will be blacked out.
+     * This is useful for parental controls where the screen should be blacked out during certain times
+     * @private
      * @param {Date} date
      * @returns {Promise<void>} A Promise that resolves once the blackout time is set.
-     * @throws {RemotePlayerError} If the player is not initialized or not loaded. if date is not a Date object or if the remote player api version is less than 2
+     * @throws {RemotePlayerError} If the player is not initialized or not loaded. if date is not a Date object or if the remote player api version is not supported
      */
-    setBlackoutTime(date) {
-        return noop("RemotePlayer.setBlackoutTime", date);
+    setScreenBlackout(date) {
+        return noop("RemotePlayer.setScreenBlackout", date);
     }
 
     /**
-     *
+     * The function resets the currently set blackout time for the screen.
+     * This is useful for parental controls to be reset the blackout time after it has been set.
+     * @private
      * @returns {Promise<void>} A Promise that resolves once the blackout time is reset.
-     * @throws {RemotePlayerError} If the player is not initialized or not loaded. if the remote player api version is less than 2
+     * @throws {RemotePlayerError} If the player is not initialized or not loaded. if the remote player api version is not supported
      */
-    resetBlackoutTime() {
-        return noop("RemotePlayer.resetBlackoutTime");
+    resetScreenBlackout() {
+        return noop("RemotePlayer.resetScreenBlackout");
     }
 
     /**

package/src/interface/utils.js

@@ -1,5 +1,4 @@
-import pack from "../../package.json";
-const { version } = pack;
+import { version } from "./version.js";
 
 /* eslint-disable no-console */
 class SdkLogger {

package/src/interface/version.js

@@ -0,0 +1 @@
+export const version = "4.3.3-13bd44c.0";