senza-sdk 4.2.64-70c0747.0 → 4.2.65-4527e57.0

package/src/{implementation/remotePlayer.js → remotePlayer.js}

@@ -1,4 +1,3 @@
-import { RemotePlayer as RemotePlayerInterface } from "../interface/remotePlayer";
 import {
     getFCID,
     isAudioSyncConfigured,
@@ -69,6 +68,7 @@ function setPlaybackInfo(playbackInfo) {
 * @typedef {Object} Config
 * @property {string} preferredAudioLanguage
 * @property {string} preferredSubtitlesLanguage
+* @property {number} minSuggestedPresentationDelay - minimal delay allowed for live playback in seconds
 * @property {boolean} autoPlay - (Not implemented yet) upon loading start playing automatically
 */
 
@@ -79,11 +79,11 @@ function setPlaybackInfo(playbackInfo) {
  * @fires ended
  * @fires error
  * @fires onloadmodechange
+ * @fires playing
  * @fires seeking (Not implemented yet)
  * @fires seeked (Not implemented yet)
- * @fires loadedmetadata (Not implemented yet)
  */
-class RemotePlayer extends RemotePlayerInterface {
+class RemotePlayer extends EventTarget {
     constructor() {
         super();
         /**
@@ -92,7 +92,8 @@ class RemotePlayer extends RemotePlayerInterface {
          */
         this._config = {
             preferredAudioLanguage: "",
-            preferredSubtitlesLanguage: ""
+            preferredSubtitlesLanguage: "",
+            minSuggestedPresentationDelay: 0
         };
         /**
          * @type {string}
@@ -162,6 +163,13 @@ class RemotePlayer extends RemotePlayerInterface {
          */
         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
@@ -525,10 +533,10 @@ class RemotePlayer extends RemotePlayerInterface {
 
     /** setting values for properties in the player configuration using an object.
      * If the config does not support a property this is a no-op.
-     * @param {Object} props the object with all the different properties to change
+     * @param {Config} props the object with all the different properties to change.
      * @example
      * remotePlayer.configure({ preferredAudioLanguage: 'en-US' })
-     *
+     * remotePlayer.configure({ minSuggestedPresentationDelay: 6 })
      * */
     configure(props) {
         Object.entries(props).forEach(([key, value]) => {
@@ -897,6 +905,9 @@ class RemotePlayer extends RemotePlayerInterface {
                 this._updateSeekListeners(video);
             }
             this._videoElement = video;
+
+            // Emit a custom event to notify about the attachment of the video element
+            this.dispatchEvent(new Event("videoelementattached"));
         }
     }
 
@@ -912,7 +923,7 @@ class RemotePlayer extends RemotePlayerInterface {
     /** Tell the remote player to load the given URL.
      * @param {string} url url to load
      * @param {number} [position] start position in seconds (if not provided, start from beginning (VOD) or current time (LTV))
-     * @returns {Promise}
+    * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg
      *
      * */
@@ -947,6 +958,7 @@ class RemotePlayer extends RemotePlayerInterface {
             this._abortSetAudioLanguage = true;
             this._abortSetSubtitleLanguage = true;
             this._abortSeeking = true;
+            this._blackoutTime = 0;
             if (reset) {
                 this._reset();
             }
@@ -977,6 +989,11 @@ class RemotePlayer extends RemotePlayerInterface {
                     message.action = "load";
                     message.audioLanguage = audioLanguage;
                     message.subtitlesLanguage = subtitlesLanguage;
+                    if (this.getConfiguration().minSuggestedPresentationDelay > 0) {
+                        message.cloudPlayerParams = {
+                            "mspd": this.getConfiguration().minSuggestedPresentationDelay
+                        };
+                    }
                 } else {
                     message.type = "setPlayableUri";
                 }
@@ -1553,6 +1570,121 @@ 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 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
      */

package/src/{implementation/senzaShakaPlayer.js → senzaShakaPlayer.js}

@@ -1,7 +1,8 @@
-import { shaka } from "../interface/senzaShakaPlayer";
-
+import * as shaka from "shaka-player";
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
 import { sdkLogger, iso6393to1 } from "./utils";
+import moment from "moment";
+
 
 //  Define custom error category
 shaka.util.Error.Category.SENZA_PLAYER_ERROR = 50;
@@ -31,6 +32,11 @@ class SenzaError extends shaka.util.Error {
 }
 
 
+// Copy the shaka module and replace the Player class with SenzaShakaPlayer
+// if we don't Copy the shaka module, the Player class will be replaced for all the other modules that import shaka
+const senzaShaka = { ...shaka };
+
+
 /**
  * SenzaShakaPlayer subclass of Shaka that handles both local and remote playback.
  *
@@ -72,9 +78,9 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @private
      * @type {number}
      * @description Timeout in milliseconds to wait for playing event
-     * @default 3000
+     * @default 4000
      */
-    _playingTimeout = 3000;
+    _playingTimeout = 4000;
 
     /**
      * @private
@@ -89,7 +95,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @description Whether to stop remote player on error
      * @default false
      */
-    _shouldStopRemotePlayerOnError = false;
+    _shouldStopOnRemotePlayerError = false;
 
     /**
      * @private
@@ -181,7 +187,7 @@ export class SenzaShakaPlayer extends shaka.Player {
                 originatesFromRemotePlayer: true
             };
 
-            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+            const response = await this.getNetworkingEngine().request(senzaShaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
 
             let responseBody = response.data;
             if (response.status < 200 || response.status >= 300) {
@@ -280,13 +286,15 @@ export class SenzaShakaPlayer extends shaka.Player {
 
 
     /**
-     * Handles errors for play promises and remote player events.
+     * Handles errors received by remote player while waiting for the playing event.
+     * The promise returned to the call for video element play will be rejected.
      * @private
      * @param {Error} error - The error object.
        */
     _handlePlayPromiseError(error) {
 
         sdkLogger.error("Error while waiting for playing event:", error);
+
         if (this._playPromiseReject) {
             this._playPromiseReject(error);
             this._playPromiseResolve = null;
@@ -296,6 +304,46 @@ export class SenzaShakaPlayer extends shaka.Player {
             clearTimeout(this._playTimeoutId);
             this._playTimeoutId = null;
         }
+
+    }
+
+    /**
+     * @private
+     * @type {number}
+     * @description Minimum suggested presentation delay in seconds
+     * @default 15
+     */
+    _minSuggestedPresentationDelay = 15;
+
+    /**
+     * Modifies the suggestedPresentationDelay in the manifest text
+     * @private
+     * @param {string} manifestText - The MPD manifest text
+     * @returns {string} - Modified manifest text , or undefined if no modification was done
+     */
+    _updateManifestDelayIfBelowMinimum(manifestText) {
+        // Look for suggestedPresentationDelay attribute
+        const match = manifestText.match(/suggestedPresentationDelay="([^"]+)"/);
+        if (match) {
+            const durationString = match[1];
+            const duration = moment.duration(durationString);
+            const currentDelay = duration.asSeconds();
+
+            sdkLogger.info(`Found suggestedPresentationDelay in manifest: ${currentDelay.toFixed(3)}s`);
+
+            if (currentDelay < this._minSuggestedPresentationDelay) {
+                // Replace the value in the manifest text with 3 decimal places
+                manifestText = manifestText.replace(
+                    /suggestedPresentationDelay="[^"]+"/,
+                    `suggestedPresentationDelay="PT${this._minSuggestedPresentationDelay.toFixed(3)}S"`
+                );
+                sdkLogger.info(`Updated manifest suggestedPresentationDelay to ${this._minSuggestedPresentationDelay.toFixed(3)}s`);
+                return manifestText;
+            }
+        } else {
+            sdkLogger.info("suggestedPresentationDelay is not defined at the manifest");
+        }
+        return undefined;
     }
 
     /**
@@ -325,14 +373,38 @@ export class SenzaShakaPlayer extends shaka.Player {
         const playTimeout = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"]?.playingEventTimeout;
         this._playingTimeout = (playTimeout >= 0) ? playTimeout*1000 : this._playingTimeout;
 
+        // Initialize minSuggestedPresentationDelay from UI settings or use default
+        const uiSettings = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"];
+        if (uiSettings?.minSuggestedPresentationDelay !== undefined) {
+            this._minSuggestedPresentationDelay = uiSettings.minSuggestedPresentationDelay;
+            sdkLogger.info(`Using configured minSuggestedPresentationDelay: ${this._minSuggestedPresentationDelay}s`);
+        }
+
         // if video element is provided, add the listeres here. In this case ,there is no need to call attach.
         if (videoElement) {
             this._attach(videoElement);
             sdkLogger.warn("SenzaShakaPlayer constructor Adding videoElement in the constructor is going to be deprecated in the future. Please use attach method instead.");
         }
 
+        this.configure({
+            manifest: {
+                defaultPresentationDelay: this._minSuggestedPresentationDelay // in seconds
+            }
+        });
+
+        remotePlayer.configure({
+            minSuggestedPresentationDelay: this._minSuggestedPresentationDelay
+        });
+
+        this.addEventListener("buffering", () => {
+            if (this.videoElement) {
+                sdkLogger.info("Buffering at time:", this.videoElement.currentTime);
+            }
+        });
+
     }
 
+
     _attach(videoElement) {
         this.videoElement = videoElement;
 
@@ -556,11 +628,12 @@ export class SenzaShakaPlayer extends shaka.Player {
         const isCritical = this._isErrorCritical(remotePlayerErrorCode);
         const error = this._createSenzaError(remotePlayerErrorCode, message, isCritical);
         const errorMap = new Map();
+        const shouldStopPlayback = this._shouldStopOnRemotePlayerError && this.videoElement && isCritical;
         errorMap.set("detail", error);
 
         // Check if we should stop playback - only for critical errors when configured
-        if (this._shouldStopRemotePlayerOnError &&
-            this.videoElement && isCritical) {
+
+        if (shouldStopPlayback) {
             try {
                 sdkLogger.warn("Stopping local player playback due to critical error");
                 // Stop only local playback
@@ -568,9 +641,11 @@ export class SenzaShakaPlayer extends shaka.Player {
             } catch (stopError) {
                 sdkLogger.error("Error while trying to stop video element playback:", stopError);
             }
+            // Handle error while waiting for play event. If the error is not critical or the system is configured not to stop remote player on error,
+            //  the playback timeout will start the local playback
+            this._handlePlayPromiseError(error);
         }
-        // Handle error while waiting for play event
-        this._handlePlayPromiseError(error);
+
         this.dispatchEvent(new shaka.util.FakeEvent("error", errorMap));
     }
 
@@ -608,16 +683,30 @@ export class SenzaShakaPlayer extends shaka.Player {
 
         // This callbakc will be activated when the manifest is loaded. It will trigger load of the remote player.
         // This will ensure that the remote player is loaded only after the manifest is loaded by local player.
-        const responseFilterCallback = async (type) => {
-            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST && !manifestLoadHandled) {
-                manifestLoadHandled = true;
+        const responseFilterCallback = async (type, response) => {
+            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST) {
                 try {
-                    await this._remotePlayerLoad(url, startTime);
-                    remoteLoadResolver();
+                    if (response.data && this._minSuggestedPresentationDelay > 0) {
+                        const manifestText = new TextDecoder().decode(response.data);
+                        const modifiedText = this._updateManifestDelayIfBelowMinimum(manifestText);
+                        if (modifiedText) {
+                            const responseData = new TextEncoder().encode(modifiedText).buffer;
+                            response.data = responseData;
+                        }
+                    }
                 } catch (error) {
-                    remoteLoadRejecter(error);
+                    sdkLogger.error("Error processing manifest:", error);
                 }
 
+                if (!manifestLoadHandled) {
+                    manifestLoadHandled = true;
+                    try {
+                        await this._remotePlayerLoad(url, startTime);
+                        remoteLoadResolver();
+                    } catch (error) {
+                        remoteLoadRejecter(error);
+                    }
+                }
             }
         };
 
@@ -680,14 +769,14 @@ export class SenzaShakaPlayer extends shaka.Player {
     /**
      * Override the configure method to add custom configuration handling
      * Supports the following additional configuration options:
-     * - shouldStopRemotePlayerOnError: boolean - If true, remote player will be stopped on error
+     * - shouldStopOnRemotePlayerError: boolean - If true, local player will be stopped on remote player error
      *
      * @override
      * @param {Object} config - Configuration object to be merged with existing config
-     * @param {boolean} [config.shouldStopRemotePlayerOnError=true] - Whether to stop remote player on error
+     * @param {boolean} [config.shouldStopOnRemotePlayerError=true] - Whether to stop local player on remote player error
      * @example
      * player.configure({
-     *   shouldStopRemotePlayerOnError: false,  // Don't stop remote player on error
+     *   shouldStopOnRemotePlayerError: false,  // Don't stop local playback  on remote player error
      *   // ... other shaka configurations
      * });
      */
@@ -695,12 +784,12 @@ export class SenzaShakaPlayer extends shaka.Player {
         sdkLogger.log("configure player with: ", JSON.stringify(config));
 
         // Handle custom configuration
-        if (config.shouldStopRemotePlayerOnError !== undefined) {
-            this._shouldStopRemotePlayerOnError = !!config.shouldStopRemotePlayerOnError;
+        if (config.shouldStopOnRemotePlayerError !== undefined) {
+            this._shouldStopOnRemotePlayerError = !!config.shouldStopOnRemotePlayerError;
             // Remove our custom config so it doesn't get passed to parent
             // Use rest operator without creating a named variable for the removed property
             // eslint-disable-next-line no-unused-vars
-            const { shouldStopRemotePlayerOnError, ...shakaConfig } = config;
+            const { shouldStopOnRemotePlayerError, ...shakaConfig } = config;
             config = shakaConfig;
         }
 
@@ -800,5 +889,5 @@ export class SenzaShakaPlayer extends shaka.Player {
 
 }
 
-shaka.Player = SenzaShakaPlayer;
-export { shaka };
+senzaShaka.Player = SenzaShakaPlayer;
+export { senzaShaka as shaka };

package/src/{implementation/utils.js → utils.js}

@@ -1,15 +1,10 @@
 import { getPlatformInfo } from "./api";
+import pack from "../package.json";
 import { sessionInfo } from "./SessionInfo";
+const { version } = pack;
 
 const REST_RESPONSE_TIMEOUT_SECONDS = 5;
 
-export function getVersion() {
-    return typeof IMPLEMENTATION_VERSION !== "undefined"
-        // eslint-disable-next-line no-undef
-        ? IMPLEMENTATION_VERSION
-        : "unknown";
-};
-
 export function getFCID() {
     return Math.round(Math.random() * 100000) + "-" + getPlatformInfo().sessionInfo?.connectionId;
 }
@@ -47,7 +42,7 @@ class SdkLogger {
         console.info(`[hs-sdk] [metrics] ${JSON.stringify(metricObj)}`);
     }
     withFields(logFields) {
-        return new SdkLogger({ ...this.logFields, ...logFields });
+        return new SdkLogger({...this.logFields, ...logFields});
     }
     formatLogString(data) {
         let logString = "[hs-sdk] " + data.join(" ");
@@ -56,13 +51,9 @@ class SdkLogger {
         }
         return logString;
     }
-    addfields(fields) {
-        this.logFields = { ...this.logFields, ...fields };
-        return this;
-    }
 }
 
-export const sdkLogger = new SdkLogger({ sdkVersion: getVersion(), url: window?.location?.href ?? "" });
+export const sdkLogger = new SdkLogger({sdkVersion: version, url: window?.location?.href ?? ""});
 
 export async function getRestResponse(messageName) {
 
@@ -73,14 +64,14 @@ export async function getRestResponse(messageName) {
 
     return new Promise((resolve, reject) => {
         const FCID = getFCID();
-        const logger = sdkLogger.withFields({ FCID });
+        const logger = sdkLogger.withFields({FCID});
         const message = {
             type: "restRequest",
             name: messageName,
             method: "GET",
             fcid: FCID
         };
-        const request = { target: "TC", waitForResponse: true, message: JSON.stringify(message) };
+        const request = {target: "TC", waitForResponse: true, message: JSON.stringify(message)};
         let timeoutHandler = 0;
         const queryId = window.cefQuery({
             request: JSON.stringify(request),