senza-sdk 4.2.65-d2761c0.0 → 4.3.1-ca3d96f.0

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

@@ -1,6 +1,9 @@
-import * as shaka from "shaka-player";
+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;
@@ -30,31 +33,7 @@ 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.
- *
- * @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;
 
@@ -76,7 +55,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;
 
@@ -139,7 +118,7 @@ export class SenzaShakaPlayer extends shaka.Player {
                     });
             }
         },
-        "pause" : () => {
+        "pause": () => {
             this._resetPlayPromise();
             this.remotePlayer.pause()
                 .catch(error => {
@@ -185,7 +164,7 @@ export class SenzaShakaPlayer extends shaka.Player {
                 originatesFromRemotePlayer: true
             };
 
-            const response = await this.getNetworkingEngine().request(senzaShaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
 
             let responseBody = response.data;
             if (response.status < 200 || response.status >= 300) {
@@ -306,13 +285,44 @@ export class SenzaShakaPlayer extends shaka.Player {
     }
 
     /**
-     * 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);
 
@@ -330,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) {
@@ -338,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;
 
@@ -386,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();
@@ -437,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 {
@@ -459,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]) {
@@ -490,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]) {
@@ -505,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;
     }
@@ -584,12 +568,6 @@ export class SenzaShakaPlayer extends shaka.Player {
         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
@@ -618,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);
+                    }
+                }
             }
         };
 
@@ -662,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;
@@ -676,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 => {
@@ -687,20 +668,6 @@ export class SenzaShakaPlayer extends shaka.Player {
         });
     }
 
-    /**
-     * Override the configure method to add custom configuration handling
-     * Supports the following additional configuration options:
-     * - 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.shouldStopOnRemotePlayerError=true] - Whether to stop local player on remote player error
-     * @example
-     * player.configure({
-     *   shouldStopOnRemotePlayerError: false,  // Don't stop local playback  on remote player error
-     *   // ... other shaka configurations
-     * });
-     */
     configure(config) {
         sdkLogger.log("configure player with: ", JSON.stringify(config));
 
@@ -810,5 +777,5 @@ export class SenzaShakaPlayer extends shaka.Player {
 
 }
 
-senzaShaka.Player = SenzaShakaPlayer;
-export { senzaShaka as shaka };
+shaka.Player = SenzaShakaPlayer;
+export { shaka };

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

@@ -1,10 +1,15 @@
 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;
 }
@@ -42,7 +47,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(" ");
@@ -51,9 +56,13 @@ class SdkLogger {
         }
         return logString;
     }
+    addfields(fields) {
+        this.logFields = { ...this.logFields, ...fields };
+        return this;
+    }
 }
 
-export const sdkLogger = new SdkLogger({sdkVersion: version, url: window?.location?.href ?? ""});
+export const sdkLogger = new SdkLogger({ sdkVersion: getVersion(), url: window?.location?.href ?? "" });
 
 export async function getRestResponse(messageName) {
 
@@ -64,14 +73,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),

package/src/interface/alarmManager.js

@@ -0,0 +1,76 @@
+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");
+ */
+
+/**
+ * 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 {
+
+    addEventListener(type, callback) {
+        noop("AlarmManager.addEventListener", type, callback);
+    }
+
+    removeEventListener(type, callback) {
+        noop("AlarmManager.removeEventListener", type, callback);
+    }
+
+    /** Set alarm to be fired at the specified time, event when ui is released
+     * @param {string} alarmName unique name for the alarm
+     * @param {number} alarmTime target time for the alarm to be fired, represented by the number of milliseconds elapsed since the epoch
+     * @param {string} [data] data to be passed back when the alarm is fired
+     * */
+    addAlarm(alarmName, alarmTime, data = "", toleranceBefore = 0, toleranceAfter = 0) {
+        noop("AlarmManager.addAlarm", alarmName, alarmTime, data, toleranceBefore, toleranceAfter);
+    }
+
+    /** Delete the specified alarm
+     * @param {string} alarmName name of alarm to be deleted
+     *
+     * */
+    deleteAlarm(alarmName) {
+        noop("AlarmManager.deleteAlarm", alarmName);
+    }
+
+    /** Delete all alarms
+     *
+     * */
+    deleteAllAlarms() {
+        noop("AlarmManager.deleteAllAlarms");
+    }
+
+    /** Async function that asks for all active alarms
+     * @returns {Promise} when resolved, returns an array of objects containing alarmName and alarmTime fields
+     * @throws {string} error string in case of an error
+     *
+     * */
+    getActiveAlarms() {
+        return noop("AlarmManager.getActiveAlarms");
+    }
+}
+
+/**
+ * @module
+ * @type {AlarmManager}
+ * @example
+ * import { alarmManager } from "senza-sdk";
+ *
+ * @return {AlarmManager} pointer to the AlarmManager singleton
+ */
+"needed for the module doc comment to be recognized";

package/src/interface/api.js

@@ -0,0 +1,8 @@
+export { Lifecycle } from "./lifecycle.js";
+export { DeviceManager } from "./deviceManager.js";
+export { PlatformManager } from "./platformManager.js";
+export { AlarmManager } from "./alarmManager.js";
+export { MessageManager } from "./messageManager.js";
+export { RemotePlayer } from "./remotePlayer.js";
+export { SenzaShakaPlayer as ShakaPlayer, shaka } from "./senzaShakaPlayer.js";
+export { showSequence, initSequence } from "./devSequence.js";

package/src/{devSequence.js → 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
+        });
+    });
+}
+