senza-sdk 4.3.2-2e967be.0 → 4.3.2-a581729.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.3.2-2e967be.0",
+    "version": "4.3.2-a581729.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

@@ -27,6 +27,7 @@ class AlarmManager extends AlarmManagerInterface {
      * @private
      */
     _init() {
+        sdkLogger.log("Initializing AlarmManager");
         if (!this._isInitialized) {
             this._isInitialized = true;
             this._addSenzaEventListeners();
@@ -94,6 +95,7 @@ class AlarmManager extends AlarmManagerInterface {
             }
         }
         );
+        sdkLogger.log("[AlarmManager] Added event listeners for system events");
     }
 
     /**

package/src/implementation/api.js

@@ -134,6 +134,7 @@ export async function init(interfaceApiVersion, showSequenceFunc, initSequenceFu
         alarmManager._init();
         deviceManager._init();
         messageManager._init();
+        sdkLogger.log("All submodules initialized");
 
 
         const devSequence = sessionInfoObj?.settings?.["ui-streamer"]?.devSequence;

package/src/implementation/deviceManager.js

@@ -54,6 +54,7 @@ class DeviceManager extends DeviceManagerInterface {
      * @private
      */
     _init() {
+        sdkLogger.log("Initializing DeviceManager");
         if (!this._isInitialized) {
             this._isInitialized = true;
             this._addSenzaEventListeners();
@@ -71,6 +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

@@ -71,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
@@ -212,6 +213,7 @@ class Lifecycle extends LifecycleInterface {
                 this._startCountdown(event.detail.isPlaying);
             }
         });
+        sdkLogger.log("[Lifecycle] Added event listeners for system events");
     }
 
     /**

package/src/implementation/messageManager.js

@@ -15,6 +15,7 @@ class MessageManager extends MessageManagerInterface {
      * @private
      */
     _init() {
+        sdkLogger.log("Initializing MessageManager");
         if (!this._isInitialized) {
             this._isInitialized = true;
             this._addSenzaEventListeners();
@@ -29,6 +30,7 @@ class MessageManager extends MessageManagerInterface {
             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

@@ -146,9 +146,7 @@ class RemotePlayer extends RemotePlayerInterface {
      * @param {Object} uiStreamerSettings ui-streamer portion of the settings taken from session info
      * */
     async _init(uiStreamerSettings, triggerEvent) {
-        if (!this._systemEventListenersAdded) {
-            this._systemEventListenersAdded = true;
-        }
+        sdkLogger.info("Initializing RemotePlayer");
         let playerState = {
             isLoaded: false,
             playbackUrl: ""
@@ -212,6 +210,7 @@ class RemotePlayer extends RemotePlayerInterface {
      * @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));
             this.dispatchEvent(new Event(e?.detail?.eventName));
@@ -294,6 +293,7 @@ class RemotePlayer extends RemotePlayerInterface {
             };
             this.dispatchEvent(licenseRequestEvent);
         });
+        sdkLogger.log("[RemotePlayer] Added event listeners for system events");
     }
 
     /** @private update audio and text tracks
@@ -1367,6 +1367,61 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
+    /**
+     * 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 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}`);
+        }
+
+        const blackoutTime = (date.getTime()/1000).toFixed(2);
+        sdkLogger.info(`remotePlayer.setScreenBlackout(): setting blackout time to ${blackoutTime}`);
+        return this._setScreenBlackout(blackoutTime);
+    }
+
+    /**
+     * 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 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}`);
+        }
+        sdkLogger.info("remotePlayer.resetScreenBlackout(): resetting blackout time");
+        return this._setScreenBlackout(0);
+    }
+
     /**
      * Getter/Setter for currentTime
      */
@@ -1718,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/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,30 @@ class RemotePlayer extends EventTarget {
         return noop("RemotePlayer.setTextTrackVisibility", visible);
     }
 
+    /**
+     * 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) {
+        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.
+     *
+     * @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() {
+        return noop("RemotePlayer.resetScreenBlackout");
+    }
+
     /**
      * Getter/Setter for currentTime
      */