senza-sdk 4.2.64 → 4.2.65-4527e57.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.2.64",
+    "version": "4.2.65-4527e57.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -15,7 +15,7 @@
         "eslint": "eslint --max-warnings 0  src test",
         "build": "npx webpack --config webpack.config.js",
         "test": "jest --coverage --verbose",
-        "testall" : "jest --coverage --verbose && npm run eslint --fix"
+        "testall": "jest --coverage --verbose && npm run eslint --fix"
     },
     "devDependencies": {
         "@babel/cli": "^7.13.16",
@@ -32,7 +32,6 @@
         "jsdoc-to-markdown": "^7.1.1",
         "webpack": "^5.72.1",
         "webpack-cli": "^5.1.4"
-
     },
     "jest": {
         "verbose": false,

package/src/lifecycle.js

@@ -784,6 +784,7 @@ class Lifecycle extends EventTarget {
             }
 
             // TODO: Need to discuss checking for a valid tenantId in the Senza platform
+            remotePlayer._blackoutTime = 0;
             const contentHubTenantId = getPlatformInfo().sessionInfo?.homeSessionInfo?.tenantInfo?.contentHubTenantId;
             const homeTenantId = getPlatformInfo().sessionInfo?.homeSessionInfo?.tenantId;
             sdkLogger.log(`SwitchTenant for ${tenantId}`);

package/src/remotePlayer.js

@@ -163,6 +163,13 @@ class RemotePlayer extends EventTarget {
          */
         this._isPlaying = false;
 
+        /**
+         * @type {string}
+         * @description the last set blackout time as epoch seconds.
+         * @private
+         */
+        this._blackoutTime = 0;
+
         /**
          * @event RemotePlayer#canplay
          * @description canplay event will be dispatched when the remote player can start play the event
@@ -951,6 +958,7 @@ class RemotePlayer extends EventTarget {
             this._abortSetAudioLanguage = true;
             this._abortSetSubtitleLanguage = true;
             this._abortSeeking = true;
+            this._blackoutTime = 0;
             if (reset) {
                 this._reset();
             }
@@ -1562,6 +1570,121 @@ class RemotePlayer extends EventTarget {
         }
     }
 
+    setBlackoutTime(date) {
+
+        if (!this._isInitialized) {
+            throw new RemotePlayerError(6500, "Cannot call setBlackoutTime() if remote player is not initialized");
+        }
+
+        if (this._loadMode !== this.LoadMode.LOADED) {
+            throw new RemotePlayerError(6001, "Cannot call setBlackoutTime() if player is not loaded");
+        }
+
+        if (!(date instanceof Date)) {
+            throw new TypeError("blackoutTime must be a Date object"); // remotePlayer 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);
+    }
+
+    resetBlackoutTime() {
+        if (!this._isInitialized) {
+            throw new RemotePlayerError(6500, "Cannot call resetBlackoutTime() if remote player is not initialized");
+        }
+
+        if (this._loadMode !== this.LoadMode.LOADED) {
+            throw new RemotePlayerError(6001, "Cannot call resetBlackoutTime() if player is not loaded");
+        }
+
+        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);
+    }
+
     /**
      * Getter/Setter for currentTime
      */