senza-sdk 4.3.1-ca3d96f.0 → 4.3.1-e113d43.0

package/src/implementation/senzaShakaPlayer.js

@@ -1,9 +1,7 @@
-import { SenzaShakaPlayer as SenzaShakaInterface, shaka } from "../interface/senzaShakaPlayer";
+import { 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;
@@ -33,7 +31,26 @@ class SenzaError extends shaka.util.Error {
 }
 
 
-export class SenzaShakaPlayer extends SenzaShakaInterface {
+/**
+ * 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 {
     /** @private {SenzaShakaPlayer|null} Previous instance of the player */
     static _prevInstance = null;
 
@@ -55,9 +72,9 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
      * @private
      * @type {number}
      * @description Timeout in milliseconds to wait for playing event
-     * @default 4000
+     * @default 3000
      */
-    _playingTimeout = 4000;
+    _playingTimeout = 3000;
 
     /**
      * @private
@@ -72,7 +89,7 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
      * @description Whether to stop remote player on error
      * @default false
      */
-    _shouldStopOnRemotePlayerError = false;
+    _shouldStopRemotePlayerOnError = false;
 
     /**
      * @private
@@ -118,7 +135,7 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
                     });
             }
         },
-        "pause": () => {
+        "pause" : () => {
             this._resetPlayPromise();
             this.remotePlayer.pause()
                 .catch(error => {
@@ -263,15 +280,13 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
 
 
     /**
-     * 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.
+     * Handles errors for play promises and remote player events.
      * @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;
@@ -281,48 +296,16 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             clearTimeout(this._playTimeoutId);
             this._playTimeoutId = null;
         }
-
     }
 
     /**
-     * @private
-     * @type {number}
-     * @description Minimum suggested presentation delay in seconds
-     * @default 15
+     * 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.
      */
-    _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);
 
@@ -340,14 +323,7 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         this._addRemotePlayerEventListeners();
         SenzaShakaPlayer._prevInstance = this;
         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`);
-        }
+        this._playingTimeout = (playTimeout >= 0) ? playTimeout*1000 : this._playingTimeout;
 
         // if video element is provided, add the listeres here. In this case ,there is no need to call attach.
         if (videoElement) {
@@ -355,25 +331,8 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             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;
 
@@ -420,11 +379,27 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         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();
@@ -455,6 +430,14 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         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 {
@@ -469,14 +452,27 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         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]) {
@@ -487,6 +483,11 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         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]) {
@@ -497,12 +498,20 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         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;
     }
@@ -547,12 +556,11 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         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 (shouldStopPlayback) {
+        if (this._shouldStopRemotePlayerOnError &&
+            this.videoElement && isCritical) {
             try {
                 sdkLogger.warn("Stopping local player playback due to critical error");
                 // Stop only local playback
@@ -560,14 +568,18 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             } 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
@@ -596,30 +608,16 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
 
         // 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, response) => {
-            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST) {
+        const responseFilterCallback = async (type) => {
+            if (type === shaka.net.NetworkingEngine.RequestType.MANIFEST && !manifestLoadHandled) {
+                manifestLoadHandled = true;
                 try {
-                    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;
-                        }
-                    }
+                    await this._remotePlayerLoad(url, startTime);
+                    remoteLoadResolver();
                 } catch (error) {
-                    sdkLogger.error("Error processing manifest:", error);
+                    remoteLoadRejecter(error);
                 }
 
-                if (!manifestLoadHandled) {
-                    manifestLoadHandled = true;
-                    try {
-                        await this._remotePlayerLoad(url, startTime);
-                        remoteLoadResolver();
-                    } catch (error) {
-                        remoteLoadRejecter(error);
-                    }
-                }
             }
         };
 
@@ -654,6 +652,13 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
 
     }
 
+    /***
+     *
+     * Configure the Player instance.
+     * @param {Object} config the configuration object
+     * @returns {Boolean}
+     */
+
     async destroy() {
         await lifecycle.moveToForeground();
         SenzaShakaPlayer._prevInstance = null;
@@ -661,6 +666,10 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         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 => {
@@ -668,16 +677,30 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         });
     }
 
+    /**
+     * 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.shouldStopOnRemotePlayerError !== undefined) {
-            this._shouldStopOnRemotePlayerError = !!config.shouldStopOnRemotePlayerError;
+        if (config.shouldStopRemotePlayerOnError !== undefined) {
+            this._shouldStopRemotePlayerOnError = !!config.shouldStopRemotePlayerOnError;
             // 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 { shouldStopOnRemotePlayerError, ...shakaConfig } = config;
+            const { shouldStopRemotePlayerOnError, ...shakaConfig } = config;
             config = shakaConfig;
         }
 

package/src/interface/alarmManager.js

@@ -1,28 +1,31 @@
 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();
+    }
+
     addEventListener(type, callback) {
         noop("AlarmManager.addEventListener", type, callback);
     }
@@ -64,13 +67,3 @@ 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
- */
-"needed for the module doc comment to be recognized";

package/src/interface/devSequence.js

@@ -204,7 +204,6 @@ const setupSequence = (components, items) => {
     };
     methodInject(components, inject, (name) => name.startsWith("_") || name.startsWith("get"));
     handleKeys(items);
-    playersEvents(components, items);
     sdkLogger.log("Sequence initialized.");
 };
 
@@ -258,37 +257,3 @@ 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,24 +1,30 @@
 import { sdkLogger, noop } from "./utils.js";
 
-const wifiInfo = {
-    level: 0,
-    quality: 0,
-    ssid: "unknown",
-    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);
- * });
- *
- */
+const wifiInfo = {};
+
 /**
+ * @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
@@ -125,18 +131,3 @@ 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";