senza-sdk 4.3.1 → 4.3.2-3c99350.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.3.1",
+    "version": "4.3.2-3c99350.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -51,9 +51,9 @@
             },
             "src/interface": {
                 "branches": 68.42,
-                "functions": 40.74,
-                "lines": 65.96,
-                "statements": 66.32
+                "functions": 40,
+                "lines": 65.28,
+                "statements": 65.65
             }
         }
     },

package/src/implementation/alarmManager.js

@@ -16,6 +16,28 @@ class AlarmManager extends AlarmManagerInterface {
             timeoutMs: 15000 // Default timeout of 15 seconds, can be overridden by _setDefaultTimeout
         });
 
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._isInitialized = false;
+    }
+
+    /**
+     * @private
+     */
+    _init() {
+        sdkLogger.log("Initializing AlarmManager");
+        if (!this._isInitialized) {
+            this._isInitialized = true;
+            this._addSenzaEventListeners();
+        }
+    }
+
+    /**
+     * @private Add event listeners for system events
+     */
+    _addSenzaEventListeners() {
         typeof document !== "undefined" && document.addEventListener("hs/alarmFiredEvent", async (e) => {
 
             if (e.detail?.alarmName) {
@@ -73,6 +95,7 @@ class AlarmManager extends AlarmManagerInterface {
             }
         }
         );
+        sdkLogger.log("[AlarmManager] Added event listeners for system events");
     }
 
     /**

package/src/implementation/api.js

@@ -2,7 +2,17 @@ import { getFCID, sdkLogger, getVersion } from "./utils.js";
 import { sessionInfo } from "./SessionInfo.js";
 import { lifecycle } from "./lifecycle.js";
 import { alarmManager } from "./alarmManager.js";
+import { remotePlayer } from "./remotePlayer.js";
+import { deviceManager } from "./deviceManager.js";
+import { messageManager } from "./messageManager.js";
 
+export { remotePlayer };
+export { lifecycle } from "./lifecycle.js";
+export { deviceManager };
+export { platformManager } from "./platformManager.js";
+export { alarmManager };
+export { messageManager };
+export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
 let authToken;
 
 const API_VERSION = "1.0";
@@ -24,8 +34,6 @@ export const auth = {
 
 };
 
-import { remotePlayer } from "./remotePlayer.js";
-export { remotePlayer };
 
 /** Should be called once to init the library
  *@example
@@ -123,6 +131,11 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         // Initialize lifecycle first to make sure the state is updated.
         await lifecycle._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
         await remotePlayer._init(sessionInfoObj?.settings?.["ui-streamer"], triggerEvent);
+        alarmManager._init();
+        deviceManager._init();
+        messageManager._init();
+        sdkLogger.log("All submodules initialized");
+
 
         const devSequence = sessionInfoObj?.settings?.["ui-streamer"]?.devSequence;
         if (devSequence) {
@@ -255,13 +268,6 @@ export function uiReady() {
     }
 }
 
-export { lifecycle } from "./lifecycle.js";
-export { deviceManager } from "./deviceManager.js";
-export { platformManager } from "./platformManager.js";
-export { alarmManager };
-export { messageManager } from "./messageManager.js";
-export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
-
 import "./devHelper.js";
 
 /**

package/src/implementation/deviceManager.js

@@ -43,7 +43,28 @@ class DeviceManager extends DeviceManagerInterface {
         wifiInfo.quality = 0;
         wifiInfo.ssid = "unknown";
         wifiInfo.bssid = "unknown";
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._isInitialized = false;
+    }
 
+    /**
+     * @private
+     */
+    _init() {
+        sdkLogger.log("Initializing DeviceManager");
+        if (!this._isInitialized) {
+            this._isInitialized = true;
+            this._addSenzaEventListeners();
+        }
+    }
+
+    /**
+     * @private Add event listeners for system events
+     */
+    _addSenzaEventListeners() {
         typeof document !== "undefined" && document.addEventListener("wifiSignalReport", (e) => {
             wifiInfo.level = e.detail.level;
             wifiInfo.quality = e.detail.quality;
@@ -51,7 +72,7 @@ class DeviceManager extends DeviceManagerInterface {
             wifiInfo.bssid = e.detail.bssid;
             this.dispatchEvent(new Event("wifiInfoUpdated"));
         });
-
+        sdkLogger.log("[DeviceManager] Added event listeners for system events");
     }
 
     get deviceInfo() {

package/src/implementation/lifecycle.js

@@ -57,53 +57,6 @@ class Lifecycle extends LifecycleInterface {
          * @private
          */
         this._autoBackgroundOnUIDelay = DEFAULT_AUTO_BACKGROUND_UI_DELAY;
-
-        typeof document !== "undefined" && document.addEventListener("hs/uistatechange", (e) => {
-            sdkLogger.log("Got hs/uistatechange", e.detail);
-            const event = new Event("onstatechange");
-            event.state = e.detail;
-            this._state = event.state;
-            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
-                this._startCountdown();
-            }
-            this.dispatchEvent(event);
-        });
-
-        typeof document !== "undefined" && document.addEventListener("hs/systemInactivity", (e) => {
-            sdkLogger.log("Got hs/systemInactivity", e.detail);
-            const event = new Event("userinactivity");
-            event.timeout = e.detail.timeout;
-            this.dispatchEvent(event);
-        });
-
-        typeof document !== "undefined" && document.addEventListener("hs/endOfSession", async () => {
-            // Create the event
-            const event = new Event("userdisconnected");
-
-            // Use the event manager to dispatch the event and wait for all listeners
-            await this._eventManager.dispatch("userdisconnected", event);
-
-            this._sendTerminatingMessage();
-        });
-
-        typeof document !== "undefined" && document.addEventListener("keydown", () => {
-            if (this._isAutoBackgroundEnabled()) {
-                if (this.state === this.UiState.BACKGROUND ||
-                    this.state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
-                    this.moveToForeground();
-                } else {
-                    this._startCountdown();
-                }
-            }
-        });
-
-        // Add playModeChange listener
-        remotePlayer.addEventListener("playModeChange", (event) => {
-            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
-                sdkLogger.log("Resetting auto background timer due to play mode change", event.detail.isPlaying);
-                this._startCountdown(event.detail.isPlaying);
-            }
-        });
     }
 
     /**
@@ -118,6 +71,7 @@ class Lifecycle extends LifecycleInterface {
      * @param {number} [uiStreamerSettings.remotePlayerApiVersion=1] - Remote player API version
      */
     async _init(uiStreamerSettings, triggerEvent) {
+        sdkLogger.log("Initializing Lifecycle");
         if (window.cefQuery) {
 
             // Get UI state
@@ -186,6 +140,11 @@ class Lifecycle extends LifecycleInterface {
                 this._triggerEventFcid = triggerEvent.fcid;
             }
 
+            // 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;
@@ -204,6 +163,59 @@ class Lifecycle extends LifecycleInterface {
         }
     }
 
+    /**
+     * @private Add event listeners for system events
+     */
+    _addSenzaEventListeners() {
+        typeof document !== "undefined" && document.addEventListener("hs/uistatechange", (e) => {
+            sdkLogger.log("Got hs/uistatechange", e.detail);
+            const event = new Event("onstatechange");
+            event.state = e.detail;
+            this._state = event.state;
+            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
+                this._startCountdown();
+            }
+            this.dispatchEvent(event);
+        });
+
+        typeof document !== "undefined" && document.addEventListener("hs/systemInactivity", (e) => {
+            sdkLogger.log("Got hs/systemInactivity", e.detail);
+            const event = new Event("userinactivity");
+            event.timeout = e.detail.timeout;
+            this.dispatchEvent(event);
+        });
+
+        typeof document !== "undefined" && document.addEventListener("hs/endOfSession", async () => {
+            // Create the event
+            const event = new Event("userdisconnected");
+
+            // Use the event manager to dispatch the event and wait for all listeners
+            await this._eventManager.dispatch("userdisconnected", event);
+
+            this._sendTerminatingMessage();
+        });
+
+        typeof document !== "undefined" && document.addEventListener("keydown", () => {
+            if (this._isAutoBackgroundEnabled()) {
+                if (this.state === this.UiState.BACKGROUND ||
+                    this.state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                    this.moveToForeground();
+                } else {
+                    this._startCountdown();
+                }
+            }
+        });
+
+        // Add playModeChange listener
+        remotePlayer.addEventListener("playModeChange", (event) => {
+            if (this._isAutoBackgroundEnabled() && this.state === this.UiState.FOREGROUND) {
+                sdkLogger.log("Resetting auto background timer due to play mode change", event.detail.isPlaying);
+                this._startCountdown(event.detail.isPlaying);
+            }
+        });
+        sdkLogger.log("[Lifecycle] Added event listeners for system events");
+    }
+
     /**
      * @private Checks if auto background is enabled including overrides.
      * @returns {boolean}

package/src/implementation/messageManager.js

@@ -5,10 +5,32 @@ class MessageManager extends MessageManagerInterface {
 
     constructor() {
         super();
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this._isInitialized = false;
+    }
+    /**
+     * @private
+     */
+    _init() {
+        sdkLogger.log("Initializing MessageManager");
+        if (!this._isInitialized) {
+            this._isInitialized = true;
+            this._addSenzaEventListeners();
+        }
+    }
+
+    /**
+     * @private Add event listeners for system events
+     */
+    _addSenzaEventListeners() {
         typeof document !== "undefined" && document.addEventListener("hs/externalEvent", (e) => {
             sdkLogger.log("Got hs/externalEvent", JSON.stringify(e.detail));
             this.dispatchEvent(new CustomEvent("message", { detail: { eventName: e.detail.eventName, payload: e.detail.payload, fcid: e.detail.fcid } }));
         });
+        sdkLogger.log("[MessageManager] Added event listeners for system events");
     }
 
     async registerGroups(groups) {

package/src/implementation/remotePlayer.js

@@ -140,6 +140,76 @@ class RemotePlayer extends RemotePlayerInterface {
          * @private
          */
         this._isPlaying = false;
+    }
+
+    /** @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));
@@ -223,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
@@ -1355,6 +1367,43 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
+    setScreenBlackout(date) {
+
+        if (!this._isInitialized) {
+            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 setScreenBlackout() if player is not loaded");
+        }
+
+        if (!(date instanceof Date)) {
+            throw new RemotePlayerError(6503, `date param must be a ${typeof new Date()} object but got ${typeof date}`);
+        }
+
+        if (this._remotePlayerApiVersion < 2) {
+            throw new RemotePlayerError(6504, `setScreenBlackout is not supported in remotePlayerApiVersion=${this._remotePlayerApiVersion}. remotePlayerApiVersion >= 2 required`);
+        }
+
+        const blackoutTime = (date.getTime()/1000).toFixed(2);
+        return this._setScreenBlackout(blackoutTime);
+    }
+
+    resetScreenBlackout() {
+        if (!this._isInitialized) {
+            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 resetScreenBlackout() if player is not loaded");
+        }
+
+        if (this._remotePlayerApiVersion < 2) {
+            throw new RemotePlayerError(6504, `resetScreenBlackout is not supported in remotePlayerApiVersion=${this._remotePlayerApiVersion}. remotePlayerApiVersion >= 2 required`);
+        }
+        return this._setScreenBlackout(0);
+    }
+
     /**
      * Getter/Setter for currentTime
      */
@@ -1706,6 +1755,53 @@ class RemotePlayer extends RemotePlayerInterface {
         sdkLogger.log(`remotePlayer _atomicSetSubtitleLanguage: textTrackId=${textTrackId} ended.`);
         return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
     }
+
+    _setScreenBlackout(blackoutTime) {
+        const functionName = blackoutTime === 0 ? "resetScreenBlackout" : "setScreenBlackout";
+        if (window.cefQuery) {
+            const FCID = getFCID();
+            const logger = sdkLogger.withFields({ FCID });
+            logger.log(`remotePlayer ${functionName}: 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 ${functionName} returned query id ${queryId}`);
+                const timeout = this._remotePlayerConfirmationTimeout + 1000;
+                timerId = setTimeout(() => {
+                    logger.log(`${functionName} reached timeout of ${timeout} ms, canceling query id ${queryId}`);
+                    window.cefQueryCancel(queryId);
+                    reject(new RemotePlayerError(6000, `${functionName} reached timeout of ${timeout} ms`));
+                }, timeout, queryId);
+            });
+        }
+        sdkLogger.error(`remotePlayer ${functionName}: window.cefQuery is undefined`);
+        return Promise.resolve(undefined);
+    }
 }
 /**
  *

package/src/interface/remotePlayer.js

@@ -116,6 +116,8 @@ export class RemotePlayerError extends Error {
  * | 6500      | Player            | remotePlayer api was called before initializing remotePlayer                                    |
  * | 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                                              |
  * | 8001      | Player            | Error pulling manifest. bad parameters                                                          |
  * | 8002      | Player            | Error pulling manifest. filters returned no data                                                |
  * | 8003      | Player            | Error pulling manifest. fetch error                                                             |
@@ -397,6 +399,25 @@ class RemotePlayer extends EventTarget {
         return noop("RemotePlayer.setTextTrackVisibility", visible);
     }
 
+    /**
+     *
+     * @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
+     */
+    setScreenBlackout(date) {
+        return noop("RemotePlayer.setScreenBlackout", date);
+    }
+
+    /**
+     *
+     * @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
+     */
+    resetScreenBlackout() {
+        return noop("RemotePlayer.resetScreenBlackout");
+    }
+
     /**
      * Getter/Setter for currentTime
      */