senza-sdk 4.3.1-e113d43.0 → 4.3.2-2e967be.0

package/src/implementation/senzaShakaPlayer.js

@@ -1,7 +1,9 @@
-import { shaka } from "../interface/senzaShakaPlayer";
+import { SenzaShakaPlayer as SenzaShakaInterface, shaka } from "../interface/senzaShakaPlayer";
 
 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,26 +33,7 @@ class SenzaError extends shaka.util.Error {
 }
 
 
-/**
- * SenzaShakaPlayer subclass of Shaka that handles both local and remote playback.
- *
- * @class SenzaShakaPlayer
- *
- * @example
- * import { SenzaShakaPlayer } from "./senzaShakaPlayer.js";
- *
- * try {
- *   const videoElement = document.getElementById("video");
- *   const player = new SenzaShakaPlayer(videoElement);
- *   await player.load("http://playable.url/file.mpd");
- *   await videoElement.play(); // will start the playback
- *
- * } catch (err) {
- *   console.error("SenzaShakaPlayer failed with error", err);
- * }
- */
-
-export class SenzaShakaPlayer extends shaka.Player {
+export class SenzaShakaPlayer extends SenzaShakaInterface {
     /** @private {SenzaShakaPlayer|null} Previous instance of the player */
     static _prevInstance = null;
 
@@ -72,9 +55,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 +72,7 @@ export class SenzaShakaPlayer extends shaka.Player {
      * @description Whether to stop remote player on error
      * @default false
      */
-    _shouldStopRemotePlayerOnError = false;
+    _shouldStopOnRemotePlayerError = false;
 
     /**
      * @private
@@ -135,7 +118,7 @@ export class SenzaShakaPlayer extends shaka.Player {
                     });
             }
         },
-        "pause" : () => {
+        "pause": () => {
             this._resetPlayPromise();
             this.remotePlayer.pause()
                 .catch(error => {
@@ -280,13 +263,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,16 +281,48 @@ export class SenzaShakaPlayer extends shaka.Player {
             clearTimeout(this._playTimeoutId);
             this._playTimeoutId = null;
         }
+
     }
 
     /**
-     * Creates an instance of SenzaShakaPlayer, which is a subclass of shaka.Player.
-     *
-     * @param {HTMLVideoElement} videoElement - The video element to be used for local playback. This parameter is optional. If not provided, the video element can be attached later using the attach method.
-     * @param {HTMLElement=} videoContainer - The videoContainer to construct UITextDisplayer
-     * @param {function(shaka.Player)=} dependencyInjector Optional callback
-   *   which is called to inject mocks into the Player.  Used for testing.
+     * @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;
+    }
+
     constructor(videoElement, videoContainer, dependencyInjector) {
         super(videoElement, videoContainer, dependencyInjector);
 
@@ -323,7 +340,14 @@ export class SenzaShakaPlayer extends shaka.Player {
         this._addRemotePlayerEventListeners();
         SenzaShakaPlayer._prevInstance = this;
         const playTimeout = getPlatformInfo()?.sessionInfo?.settings?.["ui-streamer"]?.playingEventTimeout;
-        this._playingTimeout = (playTimeout >= 0) ? playTimeout*1000 : this._playingTimeout;
+        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) {
@@ -331,8 +355,25 @@ export class SenzaShakaPlayer extends shaka.Player {
             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;
 
@@ -379,27 +420,11 @@ export class SenzaShakaPlayer extends shaka.Player {
         this._attachVideoElementToRemotePlayer();
     }
 
-    /**
-     * Overrides the attach method of shaka.Player to attach the video element.
-     *
-     * @param {HTMLVideoElement} videoElement - The video element to be used for local playback.
-     * @param {boolean} [initializeMediaSource=true] - Whether to initialize the media source.
-     */
     async attach(videoElement, initializeMediaSource = true) {
         await super.attach(videoElement, initializeMediaSource);
         this._attach(videoElement);
     }
 
-    /**
-   * Detach the player from the current media element. Leaves the player in a
-   * state where it cannot play media, until it has been attached to something
-   * else.
-   *
-   * @param {boolean=} keepAdManager
-   *
-   * @return {!Promise}
-   * @export
-   */
     async detach(keepAdManager = false) {
         // Clear any pending timeout
         this._resetPlayPromise();
@@ -430,14 +455,6 @@ export class SenzaShakaPlayer extends shaka.Player {
         this.videoElement = null;
     }
 
-    /**
-   * Unloads the currently playing stream, if any.
-   *
-   * @param {boolean=} initializeMediaSource
-   * @param {boolean=} keepAdManager
-   * @return {!Promise}
-   * @export
-   */
     async unload(initializeMediaSource = true, keepAdManager = false) {
         // Call the remote player's unload method
         try {
@@ -452,27 +469,14 @@ export class SenzaShakaPlayer extends shaka.Player {
         await super.unload(initializeMediaSource, keepAdManager);
     }
 
-    /**
-     * Overrides the getTextTracks method to use the remote player's text tracks.
-     * @returns {Array} An array of text tracks.
-     */
     getTextLanguages() {
         return Object.keys(this._textTracksMap);
     }
 
-    /**
-     * Overrides the getAudioTracks method to use the remote player's audio tracks.
-     * @returns {Array} An array of audio tracks.
-     */
     getAudioLanguages() {
         return Object.keys(this._audioTracksMap);
     }
 
-    /**
-     * Overrides the selectAudioLanguage method to use the remote player's audio track selection.
-     * @param {string} language - The language to select.
-     * @param {string=} role - The role of the track to select. (e.g. 'main', 'caption', or 'commentary')
-     */
     selectAudioLanguage(language, role) {
         sdkLogger.log("Selecting audio language:", language, "with role: ", role);
         if (this._audioTracksMap[language]) {
@@ -483,11 +487,6 @@ export class SenzaShakaPlayer extends shaka.Player {
         super.selectAudioLanguage(language, role);
     }
 
-    /**
-     * Overrides the selectTextLanguage method to use the remote player's text track selection.
-     * @param {string} language - The language to select.
-     * @param {string=} role - The role of the track to select.
-     */
     selectTextLanguage(language, role) {
         sdkLogger.log("Selecting text language:", language, "with role:", role);
         if (this._textTracksMap[language]) {
@@ -498,20 +497,12 @@ export class SenzaShakaPlayer extends shaka.Player {
         super.selectTextLanguage(language, role);
     }
 
-    /**
-     * Overrides the setTextTrackVisibility method to use the remote player's text track visibility settings.
-     * @param {boolean} visible - Whether the text tracks should be visible.
-     */
     setTextTrackVisibility(visible) {
         sdkLogger.log("Setting text track visibility to:", visible);
         remotePlayer.setTextTrackVisibility(visible);
         super.setTextTrackVisibility(visible);
     }
 
-    /**
-     * Helper function that makes it easier to check if lifecycle.state is
-     * either background or inTransitionToBackground.
-     */
     get isInRemotePlayback() {
         return lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND;
     }
@@ -556,11 +547,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,18 +560,14 @@ 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));
     }
 
-    /**
-     * Loads a media URL into both local and remote players.
-     *
-     * @param {string} url - The URL of the media to load.
-     * @returns {Promise<void>}
-     */
     async load(url, startTime, mimeType) {
 
         // Create a promise that will resolve when _remotePlayerLoad is called
@@ -608,16 +596,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);
+                    }
+                }
             }
         };
 
@@ -652,13 +654,6 @@ export class SenzaShakaPlayer extends shaka.Player {
 
     }
 
-    /***
-     *
-     * Configure the Player instance.
-     * @param {Object} config the configuration object
-     * @returns {Boolean}
-     */
-
     async destroy() {
         await lifecycle.moveToForeground();
         SenzaShakaPlayer._prevInstance = null;
@@ -666,10 +661,6 @@ export class SenzaShakaPlayer extends shaka.Player {
         return super.destroy();
     }
 
-    /**
-    * A temporary override for older versions of Shaka.
-    * Senza doesn't support out-of-band subtitles
-    */
     addTextTrack(uri, language, kind, mimeType, codec, label, forced = false) {
         sdkLogger.warn("addTextTrack is deprecated, please use addTextTrackAsync");
         super.addTextTrackAsync(uri, language, kind, mimeType, codec, label, forced).then(subs => {
@@ -677,30 +668,16 @@ 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
-     *
-     * @override
-     * @param {Object} config - Configuration object to be merged with existing config
-     * @param {boolean} [config.shouldStopRemotePlayerOnError=true] - Whether to stop remote player on error
-     * @example
-     * player.configure({
-     *   shouldStopRemotePlayerOnError: false,  // Don't stop remote player on error
-     *   // ... other shaka configurations
-     * });
-     */
     configure(config) {
         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;
         }
 

package/src/interface/alarmManager.js

@@ -1,30 +1,27 @@
 import { noop } from "./utils";
+
+/**
+ * alarm event
+ *
+ * @event AlarmManager#MyAlarm
+ * @description Fired when time of 'MyAlarm' arrives. If this alarm triggers the application load and the application doesn't call
+ * lifecycle.moveToForeground() in the alarm callback (i.e. the application remains in the background after the callback is completed),
+ * the application will be unloaded.
+ * NOTE: If you perform async operations in the callback (without moving to foreground), you must wait for the async
+ * operation to finish before returning from the callback, otherwise the application will be unloaded before the async operation is finished.<br>
+ * @example
+ * alarmManager.addEventListener("MyAlarm", async (e) => {
+ *     console.log("alarm MyAlarm arrived with data", e.detail);
+ *     await fetch("http://www.example.com");
+ * });
+ * alarmManager.addAlarm("MyAlarm", Date.now() + 60*60*1000, "MyData");
+ */
+
 /**
- * @class AlarmManager
  * AlarmManager is a singleton class that manages the alarms in the application. It fires events whose types are the names of the alarms.
  * @fires MyAlarm
  */
-export class AlarmManager extends EventTarget {
-
-    /**
-     * alarm event
-     *
-     * @event AlarmManager#MyAlarm
-     * @description Fired when time of 'MyAlarm' arrives. If this alarm triggers the application load and the application doesn't call
-     * lifecycle.moveToForeground() in the alarm callback (i.e. the application remains in the background after the callback is completed),
-     * the application will be unloaded.
-     * NOTE: If you perform async operations in the callback (without moving to foreground), you must wait for the async
-     * operation to finish before returning from the callback, otherwise the application will be unloaded before the async operation is finished.<br>
-     * @example
-     * alarmManager.addEventListener("MyAlarm", async (e) => {
-     *     console.log("alarm MyAlarm arrived with data", e.detail);
-     *     await fetch("http://www.example.com");
-     * });
-     * alarmManager.addAlarm("MyAlarm", Date.now() + 60*60*1000, "MyData");
-     */
-    constructor() {
-        super();
-    }
+class AlarmManager extends EventTarget {
 
     addEventListener(type, callback) {
         noop("AlarmManager.addEventListener", type, callback);
@@ -67,3 +64,13 @@ export class AlarmManager extends EventTarget {
         return noop("AlarmManager.getActiveAlarms");
     }
 }
+
+/**
+ * @module
+ * @type {AlarmManager}
+ * @example
+ * import { alarmManager } from "senza-sdk";
+ *
+ * @return {AlarmManager} pointer to the AlarmManager singleton
+ */
+export { AlarmManager };

package/src/interface/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/interface/deviceManager.js

@@ -1,30 +1,25 @@
 import { sdkLogger, noop } from "./utils.js";
+/**
+ * @event DeviceManager#wifiInfoUpdated
+ * @deprecated Instead, call deviceManager.getWifiInfo() periodically
+ * @example
+ * deviceManager.addEventListener("wifiInfoUpdated", () => {
+ *   console.info("Wifi info has been updated to", deviceManager.wifiInfo);
+ * });
+ *
+ */
 
-const wifiInfo = {};
+const wifiInfo = {
+    level: 0,
+    quality: 0,
+    ssid: "unknown",
+    bssid: "unknown"
+};
 
 /**
- * @class DeviceManager
  * DeviceManager is a singleton class that manages the device
  */
 export class DeviceManager extends EventTarget {
-
-    constructor() {
-        super();
-        wifiInfo.level = 0;
-        wifiInfo.quality = 0;
-        wifiInfo.ssid = "unknown";
-        wifiInfo.bssid = "unknown";
-        /**
-         * @deprecated Instead, call deviceManager.getWifiInfo() periodically
-         * @event DeviceManager#wifiInfoUpdated
-         * @example
-         * deviceManager.addEventListener("wifiInfoUpdated", () => {
-         *   console.info("Wifi info has been updated to", deviceManager.wifiInfo);
-         * });
-         *
-         */
-    }
-
     /**
      * @property {object} DeviceInfo
      * @property {string} DeviceInfo.deviceId
@@ -131,3 +126,18 @@ export class DeviceManager extends EventTarget {
         return Promise.resolve({});
     }
 }
+
+
+/**
+ * @module
+ * @type {DeviceManager}
+ * @example
+ * import { deviceManager } from "senza-sdk";
+ * const wifiInfo = await deviceManager.getWifiInfo();
+ * console.info(wifiInfo.ssid);
+ * await deviceManager.clearWifi();
+ * deviceManager.reboot();
+ *
+ * @return {DeviceManager} pointer to the DeviceManager singleton
+ */
+"needed for the module doc comment to be recognized";