senza-sdk 4.2.65-90c49ac.0 → 4.2.65-a3f8c5a.0

package/dist/bundle.js.LICENSE.txt

@@ -51,3 +51,7 @@
  Copyright 2015 Tobias Nickel
  SPDX-License-Identifier: MIT
 */
+
+//! moment.js
+
+//! moment.js locale configuration

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.2.65-90c49ac.0",
+    "version": "4.2.65-a3f8c5a.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -50,6 +50,7 @@
         }
     },
     "dependencies": {
-        "shaka-player": "^4.12.5"
+        "shaka-player": "^4.12.5",
+        "moment": "^2.30.1"
     }
 }

package/src/devSequence.js

@@ -204,6 +204,7 @@ const setupSequence = (components, items) => {
     };
     methodInject(components, inject, (name) => name.startsWith("_") || name.startsWith("get"));
     handleKeys(items);
+    playersEvents(components, items);
     sdkLogger.log("Sequence initialized.");
 };
 
@@ -257,3 +258,37 @@ export const showSequence = (visible = true) => {
     }
     container.style.visibility = visible ? "visible" : "hidden";
 };
+function playersEvents(components, items) {
+    components.remotePlayer.addEventListener("videoelementattached", () => {
+        const video = components.remotePlayer._videoElement;
+        if (video && !video._devSequenceRateChangeHandler) {
+            video._devSequenceRateChangeHandler = () => {
+                items.push({
+                    component: "localPlayer",
+                    id: "ratechange=" + video.playbackRate,
+                    time: performance.now() - currentTime
+                });
+            };
+            video.addEventListener("ratechange", video._devSequenceRateChangeHandler);
+        }
+
+        if (video && !video._devSequencePlayingHandler) {
+            video._devSequencePlayingHandler = () => {
+                items.push({
+                    component: "localPlayer",
+                    id: "playing event",
+                    time: performance.now() - currentTime
+                });
+            };
+            video.addEventListener("playing", video._devSequencePlayingHandler);
+        }
+    });
+    components.remotePlayer.addEventListener("playing", () => {
+        items.push({
+            component: "remotePlayer",
+            id: "playing event",
+            time: performance.now() - currentTime
+        });
+    });
+}
+

package/src/lifecycle.js

@@ -102,9 +102,7 @@ class Lifecycle extends EventTarget {
          * @private
          */
         this._isInitialized = false;
-        this._inTransitionToForeground = false;
-        this._inTransitionToBackground = false;
-        this._inTransitionToStandby = false;
+        this._inTransition = false;
 
         /**
          * Event listeners manager for the userdisconnected event
@@ -386,7 +384,7 @@ class Lifecycle extends EventTarget {
     // This api is part of epic HSDEV-713
     _moveToUiStandby() {
         if (window.cefQuery) {
-            this._inTransitionToStandby = true;
+            this._inTransition = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const request = { target: "TC", waitForResponse: false, internalAction: "uiExit", message: JSON.stringify({ type: "uiStandbyRequest", fcid: FCID }) };
@@ -397,12 +395,12 @@ class Lifecycle extends EventTarget {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("[ moveToUiStandby ] moveToUiStandby successfully sent");
-                        this._inTransitionToStandby = false;
+                        this._inTransition = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
                         logger.error(`[ moveToUiStandby ] moveToUiStandby failed: ${code} ${msg}`);
-                        this._inTransitionToStandby = false;
+                        this._inTransition = false;
                         reject(`moveToUiStandby failed: ${code} ${msg}`);
                     }
                 });
@@ -536,14 +534,6 @@ class Lifecycle extends EventTarget {
         this._countdown = null;
     }
 
-    /**
-     * @private
-     */
-    _isInTransition() {
-        return this._inTransitionToForeground || this._inTransitionToBackground || this._inTransitionToStandby;
-    }
-
-
     /**
      * @deprecated use lifecycle.state instead.
      * Async function that returns the ui lifecycle state
@@ -586,19 +576,14 @@ class Lifecycle extends EventTarget {
      */
     moveToForeground() {
         if (window.cefQuery) {
-            const inTransition = this._isInTransition();
-            if (inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
-                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${inTransition}`);
+            if (this._inTransition || this._state === this.UiState.FOREGROUND || this._state === this.UiState.IN_TRANSITION_TO_FOREGROUND) {
+                sdkLogger.warn(`lifecycle moveToForeground: No need to transition to foreground, state: ${this._state} transition: ${this._inTransition}`);
                 return Promise.resolve(false);
             }
-            this._inTransitionToForeground = true;
+            this._inTransition = true;
             alarmManager._moveToForegroundCalled();
             const FCID = getFCID();
             if (this._remotePlayerApiVersion >= 2) {
-                // Only update to playing UI if we started seeking in ABR. But, if we are seeking while already paused, keep the target seek state as is.
-                if (remotePlayer._isSeekingByApplication && remotePlayer._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
-                    remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-                }
                 return new Promise((resolve, reject) => {
                     const FCID = getFCID();
                     const logger = sdkLogger.withFields({ FCID });
@@ -618,14 +603,14 @@ class Lifecycle extends EventTarget {
                         onSuccess: () => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop completed successfully after ${duration} ms`);
-                            this._inTransitionToForeground = false;
+                            this._inTransition = false;
                             timerId = clearTimer(timerId);
                             resolve(true);
                         },
                         onFailure: (code, msg) => {
                             const duration = Date.now() - timeBeforeSendingRequest;
                             logger.withFields({ duration }).log(`stop failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                            this._inTransitionToForeground = false;
+                            this._inTransition = false;
                             timerId = clearTimer(timerId);
                             reject(new SenzaError(code, msg));
                         }
@@ -634,7 +619,7 @@ class Lifecycle extends EventTarget {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`stop reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `stop reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -649,11 +634,11 @@ class Lifecycle extends EventTarget {
                     persistent: false,
                     onSuccess: () => {
                         logger.log("uiActiveRequest successfully sent");
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         resolve(true);
                     },
                     onFailure: (code, msg) => {
-                        this._inTransitionToForeground = false;
+                        this._inTransition = false;
                         logger.error(`uiActiveRequest failed: ${code} ${msg}`);
                         reject(`uiActiveRequest failed: ${code} ${msg}`);
                     }
@@ -666,6 +651,10 @@ class Lifecycle extends EventTarget {
 
     _moveToBackground() {
         if (window.cefQuery) {
+            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
+                return Promise.resolve(false);
+            }
             // If audio sync is disabled, we only need to sync before remote player starts playing
             if (!isAudioSyncConfigured()) {
                 remotePlayer._syncRemotePlayerWithLocalPlayer();
@@ -677,7 +666,7 @@ class Lifecycle extends EventTarget {
                 return this._moveToUiStandby();
             }
 
-            this._inTransitionToBackground = true;
+            this._inTransition = true;
             return new Promise((resolve, reject) => {
                 const FCID = getFCID();
                 const logger = sdkLogger.withFields({ FCID });
@@ -718,14 +707,14 @@ class Lifecycle extends EventTarget {
                     onSuccess: () => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play completed successfully after ${duration} ms`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = false;
                         timerId = clearTimer(timerId);
                         resolve();
                     },
                     onFailure: (code, msg) => {
                         const duration = Date.now() - timeBeforeSendingRequest;
                         logger.withFields({ duration }).log(`play failed after ${duration} ms. Error code: ${code}, error message: ${msg}`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = false;
                         timerId = clearTimer(timerId);
                         reject(new SenzaError(code, msg));
                     }
@@ -735,7 +724,7 @@ class Lifecycle extends EventTarget {
                     const timeout = this._remotePlayerConfirmationTimeout + 1000;
                     timerId = setTimeout(() => {
                         logger.log(`play reached timeout of ${timeout} ms, canceling query id ${queryId}`);
-                        this._inTransitionToBackground = false;
+                        this._inTransition = false;
                         window.cefQueryCancel(queryId);
                         reject(new SenzaError(6000, `play reached timeout of ${timeout} ms`));
                     }, timeout, queryId);
@@ -759,11 +748,11 @@ class Lifecycle extends EventTarget {
      */
     moveToBackground() {
         if (window.cefQuery) {
-            const inTransition = this._isInTransition();
-            if (inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
-                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${inTransition}`);
+            if (this._inTransition || this._state === this.UiState.BACKGROUND || this._state === this.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                sdkLogger.warn(`lifecycle moveToBackground: No need to transition to background, state: ${this._state} transition: ${this._inTransition}`);
                 return Promise.resolve(false);
             }
+
             if (remotePlayer._isSeekingByApplication) {
                 remotePlayer._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
                 return Promise.resolve(true);
@@ -795,6 +784,7 @@ class Lifecycle extends EventTarget {
             }
 
             // TODO: Need to discuss checking for a valid tenantId in the Senza platform
+            remotePlayer._blackoutTime = undefined;
             const contentHubTenantId = getPlatformInfo().sessionInfo?.homeSessionInfo?.tenantInfo?.contentHubTenantId;
             const homeTenantId = getPlatformInfo().sessionInfo?.homeSessionInfo?.tenantId;
             sdkLogger.log(`SwitchTenant for ${tenantId}`);

package/src/remotePlayer.js

@@ -68,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
 */
 
@@ -78,9 +79,9 @@ 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 EventTarget {
     constructor() {
@@ -91,7 +92,8 @@ class RemotePlayer extends EventTarget {
          */
         this._config = {
             preferredAudioLanguage: "",
-            preferredSubtitlesLanguage: ""
+            preferredSubtitlesLanguage: "",
+            minSuggestedPresentationDelay: 0
         };
         /**
          * @type {string}
@@ -161,6 +163,13 @@ class RemotePlayer extends EventTarget {
          */
         this._isPlaying = false;
 
+        /**
+         * @type {string}
+         * @description the last set blackout time as epoch seconds.
+         * @private
+         */
+        this._blackoutTime = undefined;
+
         /**
          * @event RemotePlayer#canplay
          * @description canplay event will be dispatched when the remote player can start play the event
@@ -524,10 +533,10 @@ class RemotePlayer extends EventTarget {
 
     /** 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]) => {
@@ -896,6 +905,9 @@ class RemotePlayer extends EventTarget {
                 this._updateSeekListeners(video);
             }
             this._videoElement = video;
+
+            // Emit a custom event to notify about the attachment of the video element
+            this.dispatchEvent(new Event("videoelementattached"));
         }
     }
 
@@ -911,7 +923,7 @@ class RemotePlayer extends EventTarget {
     /** 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
      *
      * */
@@ -946,6 +958,7 @@ class RemotePlayer extends EventTarget {
             this._abortSetAudioLanguage = true;
             this._abortSetSubtitleLanguage = true;
             this._abortSeeking = true;
+            this._blackoutTime = undefined;
             if (reset) {
                 this._reset();
             }
@@ -976,6 +989,11 @@ class RemotePlayer extends EventTarget {
                     message.action = "load";
                     message.audioLanguage = audioLanguage;
                     message.subtitlesLanguage = subtitlesLanguage;
+                    if (this.getConfiguration().minSuggestedPresentationDelay > 0) {
+                        message.cloudPlayerParams = {
+                            "mspd": this.getConfiguration().minSuggestedPresentationDelay
+                        };
+                    }
                 } else {
                     message.type = "setPlayableUri";
                 }
@@ -1133,13 +1151,8 @@ class RemotePlayer extends EventTarget {
 
         // If seeking in progress, wait for seek to complete before playing
         if (this._isSeekingByApplication) {
-            if (lifecycle.state === lifecycle.UiState.FOREGROUND) {
-                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_UI");
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-            } else {
-                sdkLogger.info("application requesting play during seek. setting targetSeekPlayingState to PLAYING_ABR");
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-            }
+            sdkLogger.info("application requesting play during seek");
+            this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
             return Promise.resolve(true);
         }
         /*
@@ -1557,6 +1570,62 @@ class RemotePlayer extends EventTarget {
         }
     }
 
+    setBlackoutTime(blackoutTime) {
+
+        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 (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);
+    }
+
     /**
      * Getter/Setter for currentTime
      */
@@ -1661,7 +1730,9 @@ class RemotePlayer extends EventTarget {
             }
         }
 
-        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication) {
+        // Only allow seeking in foreground. Still ignore the initialized local player seeking event above
+        if (this._remotePlayerApiVersion >= 2 && !this._isSeekingByPlatform && !this._isSeekingByApplication &&
+            (lifecycle.state === lifecycle.UiState.FOREGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_FOREGROUND)) {
             this._atomicSeek();
         } else {
             sdkLogger.info(`Seeking: skipping seeking event to currentTime: ${playbackPosition}, internalSeek: ${this._isSeekingByPlatform}, localPlayerSeek: ${this._isSeekingByApplication}, state: ${lifecycle.state}`);
@@ -1680,16 +1751,16 @@ class RemotePlayer extends EventTarget {
      * */
     async _atomicSeek() {
         sdkLogger.info("Seeking: local video element seeking start while isPlaying: ", this._isPlaying);
-        if (this._isPlaying) {
-            if (!lifecycle._inTransitionToForeground && (lifecycle._inTransitionToBackground || lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
-                sdkLogger.info("seek in background", this._isPlaying);
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
-            } else {
-                this._targetSeekPlayingState = TargetPlayingState.PLAYING_UI;
-            }
-        } else {
-            this._targetSeekPlayingState = TargetPlayingState.PAUSED;
-        }
+
+        // Initialize the target playing state unless changed during the seek process
+        // In the future, we should allow for seeking in background. Currently, there's no
+        // way to know when the web application will call moveToForeground (i.e Before/After seek)
+        // Therefore, for now, we will assume the target is either paused or playing in ui unless
+        // specifically receiving a moveToBackground during the process.
+        // if (this._isPlaying && (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND)) {
+        //     this._targetSeekPlayingState = TargetPlayingState.PLAYING_ABR;
+        // }
+        this._targetSeekPlayingState = this._isPlaying ? TargetPlayingState.PLAYING_UI : TargetPlayingState.PAUSED;
 
         // The platform could be currently syncing audio/video using playback rate. Reset when performing seek.
         if (this._videoElement) {
@@ -1756,7 +1827,7 @@ class RemotePlayer extends EventTarget {
 
         // If in TargetPlayingState.PAUSE, no need to resume.
         // Resume without awaiting to avoid blocking the seek process anymore
-        // In case where we aborted (new load or unload called), we don't want to resume playback.
+        // In case where we aborted, we don't want to resume playback.
         if (!this._abortSeeking) {
             if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_UI) {
                 if (!this._isAudioSyncEnabled()) {
@@ -1765,8 +1836,6 @@ class RemotePlayer extends EventTarget {
                 // resume audio play only if _isAudioSyncEnabled
                 this._play(StreamType.AUDIO);
             } else if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
-                // When moving back to background, we need to put the remote player back into play mode
-                this._changePlayMode(true);
                 lifecycle._moveToBackground();
             }
         }

package/src/senzaShakaPlayer.js

@@ -1,6 +1,8 @@
 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;
@@ -76,7 +78,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @private
      * @type {number}
      * @description Timeout in milliseconds to wait for playing event
-     * @default 3000
+     * @default 4000
      */
     _playingTimeout = 4000;
 
@@ -305,6 +307,45 @@ export class SenzaShakaPlayer extends shaka.Player {
 
     }
 
+    /**
+     * @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;
+    }
+
     /**
      * Creates an instance of SenzaShakaPlayer, which is a subclass of shaka.Player.
      *
@@ -332,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;
 
@@ -618,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);
+                    }
+                }
             }
         };