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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.3.2-2e967be.0",
+    "version": "4.3.2-f445d5d.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,27 +16,6 @@ class AlarmManager extends AlarmManagerInterface {
             timeoutMs: 15000 // Default timeout of 15 seconds, can be overridden by _setDefaultTimeout
         });
 
-        /**
-         * @type {boolean}
-         * @private
-         */
-        this._isInitialized = false;
-    }
-
-    /**
-     * @private
-     */
-    _init() {
-        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) {

package/src/implementation/api.js

@@ -2,17 +2,7 @@ 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";
@@ -34,6 +24,8 @@ export const auth = {
 
 };
 
+import { remotePlayer } from "./remotePlayer.js";
+export { remotePlayer };
 
 /** Should be called once to init the library
  *@example
@@ -131,10 +123,6 @@ 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();
-
 
         const devSequence = sessionInfoObj?.settings?.["ui-streamer"]?.devSequence;
         if (devSequence) {
@@ -267,6 +255,13 @@ 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,27 +43,7 @@ class DeviceManager extends DeviceManagerInterface {
         wifiInfo.quality = 0;
         wifiInfo.ssid = "unknown";
         wifiInfo.bssid = "unknown";
-        /**
-         * @type {boolean}
-         * @private
-         */
-        this._isInitialized = false;
-    }
 
-    /**
-     * @private
-     */
-    _init() {
-        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;
@@ -71,6 +51,7 @@ class DeviceManager extends DeviceManagerInterface {
             wifiInfo.bssid = e.detail.bssid;
             this.dispatchEvent(new Event("wifiInfoUpdated"));
         });
+
     }
 
     get deviceInfo() {

package/src/implementation/lifecycle.js

@@ -57,6 +57,53 @@ 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);
+            }
+        });
     }
 
     /**
@@ -139,11 +186,6 @@ 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;
@@ -162,58 +204,6 @@ 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);
-            }
-        });
-    }
-
     /**
      * @private Checks if auto background is enabled including overrides.
      * @returns {boolean}
@@ -633,6 +623,7 @@ class Lifecycle extends LifecycleInterface {
             }
 
             // 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/implementation/messageManager.js

@@ -5,26 +5,6 @@ class MessageManager extends MessageManagerInterface {
 
     constructor() {
         super();
-        /**
-         * @type {boolean}
-         * @private
-         */
-        this._isInitialized = false;
-    }
-    /**
-     * @private
-     */
-    _init() {
-        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 } }));

package/src/implementation/remotePlayer.js

@@ -140,78 +140,14 @@ 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) {
-        if (!this._systemEventListenersAdded) {
-            this._systemEventListenersAdded = true;
-        }
-        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);
-    }
+        /**
+         * @type {string}
+         * @description the last set blackout time as epoch seconds.
+         * @private
+         */
+        this._blackoutTime = 0;
 
-    /**
-     * @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));
@@ -296,6 +232,65 @@ class RemotePlayer extends RemotePlayerInterface {
         });
     }
 
+    /** @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);
+    }
+
     /** @private update audio and text tracks
      * @param {Object} playbackMetadata playback metadata that comes along the hs/playback event or trigger event
      * */
@@ -756,6 +751,7 @@ class RemotePlayer extends RemotePlayerInterface {
             this._abortSetAudioLanguage = true;
             this._abortSetSubtitleLanguage = true;
             this._abortSeeking = true;
+            this._blackoutTime = 0;
             if (reset) {
                 this._reset();
             }
@@ -1367,6 +1363,129 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
+    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 RemotePlayerError(6503, `date param must be a ${typeof new Date()} object but got ${typeof date}`);
+        }
+
+        if (this._remotePlayerApiVersion < 2) {
+            throw new RemotePlayerError(6504, `setBlackoutTime is not supported in remotePlayerApiVersion=${this._remotePlayerApiVersion}. remotePlayerApiVersion >= 2 required`);
+        }
+
+        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 (this._remotePlayerApiVersion < 2) {
+            throw new RemotePlayerError(6504, `resetBlackoutTime is not supported in remotePlayerApiVersion=${this._remotePlayerApiVersion}. remotePlayerApiVersion >= 2 required`);
+        }
+
+        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
      */

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
+     */
+    setBlackoutTime(date) {
+        return noop("RemotePlayer.setBlackoutTime", 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
+     */
+    resetBlackoutTime() {
+        return noop("RemotePlayer.resetBlackoutTime");
+    }
+
     /**
      * Getter/Setter for currentTime
      */