senza-sdk 4.1.5 → 4.2.0

package/dist/bundle.js.LICENSE.txt

@@ -0,0 +1,53 @@
+/*
+ @license
+ Copyright 2006 The Closure Library Authors
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Copyright 2008 The Closure Library Authors
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ EME Encryption Scheme Polyfill
+ Copyright 2019 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ MSS Transmuxer
+ Copyright 2015 Dash Industry Forum
+ SPDX-License-Identifier: BSD-3-Clause
+*/
+
+/*
+ @license
+ Shaka Player
+ Copyright 2016 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Shaka Player
+ Copyright 2022 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ Shaka Player
+ Copyright 2023 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ tXml
+ Copyright 2015 Tobias Nickel
+ SPDX-License-Identifier: MIT
+*/

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.1.5",
+    "version": "4.2.0",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -26,8 +26,8 @@
         "eslint-plugin-jest": "^26.1.1",
         "jest": "^27.5.1",
         "jsdoc-to-markdown": "^7.1.1",
-        "webpack-cli": "^5.1.4",
-        "webpack": "^5.72.1"
+        "webpack": "^5.72.1",
+        "webpack-cli": "^5.1.4"
     },
     "jest": {
         "verbose": false,
@@ -44,5 +44,8 @@
                 "statements": 92
             }
         }
+    },
+    "dependencies": {
+        "shaka-player": "^4.12.5"
     }
 }

package/src/api.js

@@ -384,6 +384,9 @@ export { platformManager } from "./platformManager";
 export { alarmManager } from "./alarmManager";
 export { messageManager } from "./messageManager";
 export { initSequence, showSequence } from "./devSequence";
+export {SenzaShakaPlayer as ShakaPlayer} from "./senzaShakaPlayer";
+
+
 import "./devHelper";
 
 /**

package/src/devHelper.js

@@ -1,26 +1,17 @@
-import { lifecycle,remotePlayer } from "./api";
+import { lifecycle, remotePlayer } from "./api";
 import { sdkLogger } from "./utils";
 
 const timeout = 500;
 let timerId;
-let currentState;
-
-lifecycle.getState()?.then((state) => {
-    currentState = state;
-});
-
-lifecycle.addEventListener("onstatechange", (e) => {
-    currentState = e.state;
-});
 
 const handleHintLogging = (event) => {
-    if (currentState === "background" || currentState === "inTransitionToBackground") {
+    if (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND) {
         if (timerId) {
             clearTimeout(timerId);
         }
         timerId = setTimeout(() => {
-            if (currentState === "background" || currentState === "inTransitionToBackground") {
-                sdkLogger.log(`${event.type} event received while in '${currentState}' state and there was no call to lifecycle.moveToForeground() for ${timeout} ms. Make sure to call it if you want to move to foreground.`);
+            if (lifecycle.state === lifecycle.UiState.BACKGROUND || lifecycle.state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                sdkLogger.log(`${event.type} event received while in '${lifecycle.state}' state and there was no call to lifecycle.moveToForeground() for ${timeout} ms. Make sure to call it if you want to move to foreground.`);
             }
             timerId = 0;
         }, timeout);

package/src/remotePlayer.js

@@ -541,9 +541,9 @@ class RemotePlayer extends EventTarget {
             throw new RemotePlayerError(6500, "Cannot call load() if remote player is not initialized");
         }
         if (url && window.cefQuery) {
-            const state = await lifecycle.getState();
-            if (state === "background" || state === "inTransitionToBackground") {
-                throw new RemotePlayerError(6002, "Cannot call load() while in state 'background' or 'inTransitionToBackground'");
+            const state = lifecycle.state;
+            if (state === lifecycle.UiState.BACKGROUND || state === lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND) {
+                throw new RemotePlayerError(6002, `Cannot call load() while in state '${lifecycle.UiState.BACKGROUND}' or '${lifecycle.UiState.IN_TRANSITION_TO_BACKGROUND}'`);
             }
             if (this._loadMode === this.LoadMode.LOADING) {
                 throw new RemotePlayerError(6501, "Cannot call load() while previous load is still in progress");

package/src/senzaShakaPlayer.js

@@ -0,0 +1,152 @@
+import { remotePlayer, lifecycle } from "./api";
+import { sdkLogger } from "./utils";
+import shaka from "shaka-player";
+/**
+ * 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 {
+    /**
+     * Creates an instance of SenzaShakaPlayer, which is a subclass of shaka.Player.
+     *
+     * @param {HTMLVideoElement} videoElement - The video element to be used for local playback.
+     */
+    constructor(videoElement, videoContainer, dependencyInjector) {
+        super(videoElement, videoContainer, dependencyInjector);
+        this.videoElement = videoElement;
+        this.remotePlayer = remotePlayer;
+
+        this.remotePlayer.attach(this.videoElement);
+
+        this.addEventListeners();
+    }
+
+    addEventListeners() {
+        this.remotePlayer.addEventListener("ended", () => {
+            sdkLogger.log("remotePlayer ended");
+            lifecycle.moveToForeground();
+            this.videoElement.dispatchEvent(new Event("ended"));
+        });
+
+        this.remotePlayer.addEventListener("error", (event) => {
+            sdkLogger.log("remotePlayer error:", event.detail.errorCode, event.detail.message);
+            this.videoElement.dispatchEvent(new CustomEvent("error", event));
+        });
+
+        this.remotePlayer.addEventListener("timeupdate", () => {
+            if (!this.isInRemotePlayback) {
+                return;
+            }
+            this.videoElement.currentTime = this.remotePlayer.currentTime;
+        });
+
+        this.addEventListener("error", (event) => {
+            sdkLogger.log("localPlayer error:", event.detail.errorCode, event.detail.message);
+        });
+
+        this.videoElement.addEventListener("play", () => {
+            this.remotePlayer.play();
+        });
+
+        this.videoElement.addEventListener("pause", () => {
+            this.remotePlayer.pause();
+        });
+
+        this.videoElement.addEventListener("seeked", () => {
+            this.remotePlayer.currentTime = this.videoElement.currentTime;
+        });
+
+
+        this.remotePlayer.addEventListener("license-request", async (event) => {
+            sdkLogger.log("remotePlayer", "license-request", "Got license-request event from remote player");
+
+            // Extract license body from event
+            const requestBuffer = event?.detail?.licenseRequest;
+            const requestBufferStr = String.fromCharCode.apply(null, new Uint8Array(requestBuffer));
+            const decodedLicenseRequest = window.atob(requestBufferStr); // Decode from base64
+            const licenseRequestBytes = Uint8Array.from(decodedLicenseRequest, (l) => l.charCodeAt(0));
+
+            const request = {
+                body: licenseRequestBytes.buffer,
+                uris: [this.getConfiguration().drm.servers["com.widevine.alpha"]], // TODO: safe gaurd against undefined and other server types
+                method: "POST"
+            };
+
+            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+
+            let responseBody = response.data;
+            if (response.status !== 200) {
+                responseBody = response.data ?? String.fromCharCode(new Uint8Array(response.data));
+                sdkLogger.error("remotePlayer", "license-request", "failed to to get response from widevine:", response.status, responseBody);
+            }
+            // Write response to remote player
+            sdkLogger.log("remotePlayer", "license-request", "Writing response to remote player", response.status);
+            event.writeLicenseResponse(response.status, responseBody);
+
+        });
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Moves playback to local player.
+     *
+     * @returns {Promise<void>}
+     */
+    async moveToLocalPlayback() {
+        await lifecycle.moveToForeground();
+    }
+
+    /**
+     * Moves playback to remote player.
+     * The timecode needs to be synced here if audiosync is not enabled.
+     *
+     * @returns {Promise<void>}
+     */
+    async moveToRemotePlayback() {
+        this.remotePlayer.currentTime = this.videoElement.currentTime;
+        await lifecycle.moveToBackground();
+    }
+
+    /**
+     * 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) {
+        if (!this.isInRemotePlayback || remotePlayer.getAssetUri() !== url) {
+            try {
+                await this.remotePlayer.load(url);
+            } catch (error) {
+                sdkLogger.log("Couldn't load remote player. Error:", error);
+            }
+        }
+        try {
+            await super.load(url, startTime, mimeType);
+        } catch (error) {
+            sdkLogger.log("Couldn't load local player. Error:", error);
+        }
+    }
+
+}