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

package/src/interface/remotePlayer.js

@@ -0,0 +1,470 @@
+import { noop } from "./utils";
+
+// TODO: check that the link below to the error list is working on dashreadme
+/** Error object to be thrown on remotePlayer api failures.
+ * [See error list]{@link RemotePlayer#error}
+ */
+export class RemotePlayerError extends Error {
+}
+
+/**
+* @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
+*/
+
+/**
+ * @event RemotePlayer#canplay
+ * @description canplay event will be dispatched when the remote player can start play the event
+ * @example
+ * remotePlayer.addEventListener("canplay", () => {
+ *   console.info("remotePlayer canplay");
+ *   remotePlayer.play();
+ * });
+ */
+/**
+* @event RemotePlayer#loadedmetadata
+* @description loadedmetadata event will be dispatched when the remote player metadata is loaded
+* and the audio/video tracks are available
+* @example
+* remotePlayer.addEventListener("loadedmetadata", () => {
+*   console.info("remotePlayer loadedmetadata", remotePlayer.getAudioTracks(), remotePlayer.getTextTracks());
+* });
+*/
+
+/**
+ * @event RemotePlayer#timeupdate
+ * @example
+ * remotePlayer.addEventListener("timeupdate", () => {
+ *   console.info("remotePlayer timeupdate", remotePlayer.currentTime);
+ *   localPlayer.getMediaElement().currentTime = remotePlayer.currentTime || 0;
+ * });
+ */
+
+/**
+ * @event RemotePlayer#tracksupdate
+ * @example
+ * remotePlayer.addEventListener("tracksupdate", () => {
+ *   console.info("remotePlayer tracksupdate", remotePlayer.getAudioTracks(), remotePlayer.getTextTracks());
+ * });
+ */
+
+/**
+ * @event RemotePlayer#ended
+ * @example
+ * remotePlayer.addEventListener("ended", () => {
+ *   console.info("remotePlayer ended");
+ * });
+ */
+
+/**
+ * @event RemotePlayer#onloadmodechange
+ * @example
+ * remotePlayer.addEventListener("onloadmodechange", () => {
+ *   console.info("remotePlayer load mode changed to", remotePlayer.getLoadMode());
+ * });
+ */
+
+/**
+ * @event RemotePlayer#error
+ * @type {object}
+ * @property {int} detail.errorCode
+ * @property {string} detail.message
+ *
+ * @see Possible error codes:
+ *
+ * | Code      | Domain            | Description                                                                                     |
+ * | :-------- | :---------------- | :-----------------------------------------------------------------------------------------------|
+ * | 23        | Player            | load() failed due to remote player initialization error                                         |
+ * | 98        | Player            | load() failed due to remote player failure to send message to the client                        |
+ * | 99        | Player            | load() failed due to remote player reporting invalid message                                    |
+ * | 1000      | Encrypted content | Failed to create or initialise the CDM                                                          |
+ * | 1001      | Encrypted content | Failed to create a CDM session                                                                  |
+ * | 1002      | Encrypted content | CDM failed to generate a license request                                                        |
+ * | 1003      | Encrypted content | The CDM rejected the license server response                                                    |
+ * | 1004      | Encrypted content | The CDM rejected the license server certificate                                                 |
+ * | 1005      | Encrypted content | All keys in the license have expired                                                            |
+ * | 1006      | Encrypted content | Output device is incompatible with the license requirements (HDCP)                              |
+ * | 1007      | Encrypted content | The device has been revoked                                                                     |
+ * | 1008      | Encrypted content | The device secrets aren't available                                                             |
+ * | 1009      | Encrypted content | Keys are loaded but the KID requested by playback isn't found. The app has likely issued a license for the wrong content or there is a mismatch between the KIDs in the license and the data plane |
+ * | 1010      | Encrypted content | The CDM failed to provision, therefore it is not possible to play encrypted content             |
+ * | 1100      | Encrypted content | The CDM session has already received a license response. The app has likely issued 2, or more, license responses for the same request. The subsequent licenses will be ignored so this error is informational only |
+ * | 1101      | Encrypted content | The license has been rejected since an error was received by the CDM. The app has likely sent a non-200 code to `WriteLicenseResponse` |
+ * | 1102      | Encrypted content | A license response wasn't received from the app within a pre-defined timeout                    |
+ * | 1103      | Encrypted content | The CDM session associated with this license response is in an invalid state. This is an internal Senza platform error |
+ * | 1104      | Encrypted content | The CDM failed to send a license request to the app. This is an internal Senza platform error   |
+ * | 1999      | Encrypted content | An unknown encrypted content error                                                              |
+ * | 2000      | Player            | Content makes reference to no or unsupported key system                                         |
+ * | 3000      | Player            | Unexpected problem with playback, only used if no more specific code in 3xxx range applies      |
+ * | 3001      | Player            | Problem accessing content manifest, only used if no more specific code in 8xxx range applies    |
+ * | 3002      | Player            | Unexpectedly stopped playback                                                                   |
+ * | 3100      | Player            | Problem parsing MP4 content                                                                     |
+ * | 3200      | Player            | Problem with decoder                                                                            |
+ * | 3300      | Player            | DRM keys unavailable, player waited for keys but none arrived                                   |
+ * | 3400      | Player            | Problem accessing segments, only used if no more specific code in 34xx range applies            |
+ * | 3401      | Player            | Problem accessing segments, connection issue or timeout                                         |
+ * | 3402      | Player            | Problem accessing segments, server returned HTTP error code                                     |
+ * | 3403      | Player            | Problem accessing segments, server authentication issue                                         |
+ * | 3404      | Player            | Problem accessing segments, server returned not found                                           |
+ * | 3900-3999 | Player            | Internal player error                                                                           |
+ * | 6000      | Player            | The remote player api call has reached the configurable timeout with no response from the remote player |
+ * | 6001      | Player            | play() was called while the remote player is not loaded                                         |
+ * | 6002      | Player            | load() was called while the application was in state 'background' or 'inTransitionToBackground' |
+ * | 6500      | Player            | remotePlayer api was called before initializing remotePlayer                                    |
+ * | 6501      | Player            | load() was called while previous load/unload was still in progress                              |
+ * | 6502      | Player            | unload() was called while previous unload/load was still in progress                            |
+ * | 8001      | Player            | Error pulling manifest. bad parameters                                                          |
+ * | 8002      | Player            | Error pulling manifest. filters returned no data                                                |
+ * | 8003      | Player            | Error pulling manifest. fetch error                                                             |
+ * | 8004      | Player            | Error pulling manifest. parse error                                                             |
+ * | 8005      | Player            | Error pulling manifest. stale manifest detected                                                 |
+ * | 8006      | Player            | Error updating manifest. internal cache error                                                   |
+ * | 8007      | Player            | Error updating manifest. internal error during backoff                                          |
+ * | 8008      | Player            | Error pulling manifest. sidx parsing error                                                      |
+ * | 8009      | Player            | Error pulling manifest. internal error                                                          |
+ *
+ * @example
+ * remotePlayer.addEventListener("error", (event) => {
+ *   console.error("received remotePlayer error:", event.detail.errorCode, event.detail.message);
+ * });
+ */
+/**
+ * @event RemotePlayer#playing
+ * @description playing event will be dispatched when the remote player started playback of the first audio frame. This event can be used to synchronize the local player with the remote player.
+ * @example
+ * remotePlayer.addEventListener("playing", () => {
+ *   console.info("remotePlayer playing");
+ * });
+ * */
+/**
+ * @event RemotePlayer#license-request
+ * @description Fired whenever the platform requires a license to play encrypted content.
+ * The Web App is responsible for passing the (opaque) license request blob to the license server and passing the (opaque) license server response to the CDM by calling the `writeLicenseResponse` method on the event.
+ * @type {LicenseRequestEvent}
+ * @property {object} detail - Object containing ievent data
+ * @property {string} detail.licenseRequest - Base64 coded opaque license request. The app is responsible for decoding the request before sending to the license server. Note that after decoding, the request may still be in Base64 form and this form should be sent to the license server without further decoding
+ * @property {writeLicenseResponse} writeLicenseResponse - Write the license server response to the platform
+ * @example
+ * Whilst the payload structure and access controls are specific to each license server implementation, the Widevine UAT license server requires no authentication and minimal payload formatting and therefore serves as a useful case study that may be adapted.
+ *
+ *   remotePlayer.addEventListener("license-request", async (event) => {
+ *       console.log("Got license-request event");
+ *       const requestBuffer = event?.detail?.licenseRequest;
+ *       const requestBufferStr = String.fromCharCode.apply(null, new Uint8Array(requestBuffer));
+ *       console.log("License Request in base64:", requestBufferStr);
+ *       const decodedLicenseRequest = window.atob(requestBufferStr); // from base 64
+ *       const licenseRequestBytes = Uint8Array.from(decodedLicenseRequest, (l) => l.charCodeAt(0));
+ *       // call Google API
+ *       const res = await getLicenseFromServer(licenseRequestBytes.buffer);
+ *       console.log("Writing response to platform ", res.code, res.responseBody);
+ *       event.writeLicenseResponse(res.code, res.responseBody);
+ *   });
+
+ *   async function getLicenseFromServer(licenseRequest) {
+ *       console.log("Requesting License from Widevine server");
+ *       const response = await fetch("https://proxy.uat.widevine.com/proxy", {
+ *           "method": "POST",
+ *           "body": licenseRequest,
+ *           "headers" : {
+ *               "Content-Type": "application/octet-stream"
+ *           }
+ *       });
+ *       const code = response.status;
+ *       if (code !== 200) {
+ *           console.error("failed to to get response from widevine:", code);
+ *           const responseBody = await response.text();
+ *           console.error(responseBody);
+ *           return {code, responseBody};
+ *       }
+ *       const responseBody = await response.arrayBuffer();
+ *       console.info("Got response: ");
+ *       return {code, responseBody};
+ *   }
+ */
+
+
+/**
+ * RemotePlayer a singleton class to communicate with remote player
+ * @fires timeupdate
+ * @fires tracksupdate
+ * @fires ended
+ * @fires error
+ * @fires onloadmodechange
+ * @fires seeking (Not implemented yet)
+ * @fires seeked (Not implemented yet)
+ * @fires loadedmetadata (Not implemented yet)
+ * @fires canplay
+ * @fires license-request
+ */
+export class RemotePlayer extends EventTarget {
+
+    /**
+     * @typedef {Object} LoadMode
+     * @property {string} NOT_LOADED
+     * @property {string} LOADING
+     * @property {string} LOADED
+     * @property {string} UNLOADING
+     */
+    LoadMode = Object.freeze({
+        NOT_LOADED: "notLoaded",
+        LOADING: "loading",
+        LOADED: "loaded",
+        UNLOADING: "unloading"
+    });
+
+    /** get the player configuration.
+     * @returns {Config}
+     * */
+    getConfiguration() {
+        return { preferredAudioLanguage: "", preferredSubtitlesLanguage: "" };
+    }
+
+    /** 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
+     * @example
+     * remotePlayer.configure({ preferredAudioLanguage: 'en-US' })
+     *
+     * */
+    configure(props) {
+        noop("RemotePlayer.configure", props);
+    }
+
+    /** In order to support a seamless switch between the video in the UI and ABR, the web application must
+     * register the video element being used for the currently played video before calling the load and play apis.
+     * @param {object} video The video element currently playing video in the web application
+     * @deprecated use attach function instead
+     * */
+    registerVideoElement(video) {
+        this.attach(video);
+    }
+
+    /** In order to support a seamless switch between the video in the UI and ABR, the web application must
+     * attach the video element being used for the currently played video before calling the load and play apis.
+     * @param {object} video The video element currently playing video in the web application
+     * */
+    attach(video) {
+        noop("RemotePlayer.attach", video);
+    }
+
+    /** Detach the video element from the remote player
+     */
+    detach() {
+        noop("RemotePlayer.detach");
+    }
+
+    /** 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}
+     * @throws {RemotePlayerError} error object contains code & msg
+     *
+     * */
+    async load(url, position) {
+        return noop("RemotePlayer.load", url, position);
+    }
+
+    /**
+     * Play loaded URL. Assuming load was called before.
+     * Need to call lifecycle.moveToBackground() in order to move the ui to the background and display the remote player playback in full screen
+     * @example
+     * remotePlayer.load("https://example.com/video.mp4", 0);
+     * remotePlayer.play();
+     * lifecycle.moveToBackground();
+     *
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     */
+    async play() {
+        return noop("RemotePlayer.play");
+    }
+
+    /** Pauses the currently playing audio or video
+     * When pausing in background, it will pause all streams (audio, video, subtitles) to support pausing in background.
+     * When pausing in foreground, if audio in ui enabled, it will only pause audio stream.
+     * When pausing in foreground, if audio is not enabled, remote player is not playing and therefore no call is sent.
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     *
+     * */
+    async pause() {
+        return noop("RemotePlayer.pause");
+    }
+
+    /** Stop playback
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     * */
+    async stop() {
+        return noop("RemotePlayer.stop");
+    }
+
+    /** Get the currently loaded uri, or empty string is player is not loaded.
+     * @returns {string} loaded uri
+     * @throws {RemotePlayerError} error object contains code & msg
+     *
+     * */
+    getAssetUri() {
+        return "";
+    }
+
+    /** Get the current load mode (either NOT_LOADED or LOADING or LOADED).
+     * @returns {LoadMode} current load mode
+     * @throws {RemotePlayerError} error object contains code & msg
+     * @example
+     * import { remotePlayer } from "senza-sdk";
+     * const loadMode = remotePlayer.getLoadMode();
+     * if (loadMode === remotePlayer.LoadMode.LOADED) {
+     *     console.log("remote player is currently loaded");
+     * }
+     *
+     * */
+    getLoadMode() {
+        return RemotePlayer.LoadMode.NOT_LOADED;
+    }
+
+    /**
+    * @typedef {Object} TextTrack
+    * @property {string} id - A unique ID for the track
+    * @property {string} lang - The track's language
+    * @property {boolean} selected - Whether the track is selected
+    * @property {boolean} autoTranslate - (Optional) Whether the track is an auto-translated language
+    */
+    /** Get all the text (subtitles) tracks.
+    * Text tracks are available only after playing content and returning to the UI.
+    * When text tracks are updated, the @event tracksupdate if fired.
+    * Auto Translation languages are returned only for VOD assets where there is at least one text track in the manifest to be used for translation.
+    * The list of tracks is sorted ascending to two parts by the lang key in the following order:
+    * 1. The actual text tracks which is available in the asset manifest and the selected track
+    * 2. Auto-Translation tracks
+    * @returns {TextTrack[]} an array of TextTracks if available, otherwise - empty array
+    *
+    * */
+    getTextTracks() {
+        return [];
+    }
+
+    /**
+    * @typedef {Object} AudioTrack
+    * @property {string} id - A unique ID for the track
+    * @property {string} lang - The track's language
+    * @property {boolean} selected - Whether the track is selected
+    */
+    /** Get all the audio tracks.
+     * Text tracks are available only after playing content and returning to the UI.
+     * When audio tracks are updated, the @event tracksupdate is fired.
+     * @returns {AudioTrack[]} an array of objects if available, otherwise - empty array
+     *
+     * */
+    getAudioTracks() {
+        return [];
+    }
+
+    /** Select a specific audio track.
+     * Track id should come from a call to getAudioTracks.
+     * If no tracks exist - this is a no-op.
+     * If the id does not match the id of any of the existing tracks - this is a no-op.
+     * @param {string} audioTrackId - The ID of the audio track to select.
+     * @returns {Promise<void>} A Promise that resolves once the selection process is complete.
+     * @throws {RemotePlayerError} If the player is not initialized or not loaded.
+     **/
+    async selectAudioTrack(audioTrackId) {
+        return noop("RemotePlayer.selectAudioTrack", audioTrackId);
+    }
+
+    /** Select a specific text (subtitle) track.
+     * Track id should come from a call to getTextTracks.
+     * If no tracks exist - this is a no-op.
+     * If the id does not match the id of any of the existing tracks - this is a no-op.
+     * @param {string} textTrackId - The ID of the text track to select.
+     * @returns {Promise<void>} A Promise that resolves once the selection process is complete.
+     * @throws {RemotePlayerError} If the player is not initialized or not loaded.
+     * */
+    async selectTextTrack(textTrackId) {
+        return noop("RemotePlayer.selectTextTrack", textTrackId);
+    }
+
+    /**
+     * Enable or disable the subtitles.
+     * If the player is in an unloaded state, the request will be applied next time content is played.
+     * @param {boolean} visible whether the subtitles are visible or not
+     * @throws {TypeError} if visible is not a boolean variable
+     */
+    setTextTrackVisibility(visible) {
+        return noop("RemotePlayer.setTextTrackVisibility", visible);
+    }
+
+    /**
+     * Getter/Setter for currentTime
+     */
+    get currentTime() {
+        return 0;
+    }
+
+    set currentTime(playbackPosition) {
+        noop("RemotePlayer.currentTime", playbackPosition);
+    }
+
+    /**
+     * For VOD asset, the duration of the asset
+     * @readonly
+     */
+    get duration() {
+        return 0;
+    }
+
+    /**
+     * Whether the subtitles are visible or not.
+     * @readonly
+     */
+    get textTrackVisibility() {
+        return false;
+    }
+
+    /** Get the presentation start time as a date. This should only be called when the player has loaded a live stream.
+     * If the player has not loaded a live stream, this will return null.
+     * @returns {Date} presentation start time
+     *
+     * */
+    getPresentationStartTimeAsDate() {
+        return null;
+    }
+
+    /** Tell the remote player to unload the loaded URL.
+     * @returns {Promise}
+     * @throws {RemotePlayerError} error object contains code & msg
+     * @alpha API has not yet been released
+     *
+     * */
+    async unload() {
+        return noop("RemotePlayer.unload");
+    }
+
+    /**
+     * @function writeLicenseResponse
+     * @param {number} statusCode - License server HTTP response code, e.g. 200, 401, etc. Must be 200 to indicate a successful license exchange.
+     * @param {string} response - License server response as opaque binary data in an ArrayBuffer.
+     * @private
+     */
+}
+
+/**
+ * @module
+ * @private
+ * @type {RemotePlayer}
+ * @example
+ * import { init, remotePlayer } from "senza-sdk";
+ * await init();
+ * try {
+ *     await remotePlayer.load("http://playable.url/file.mp4");
+ *     remotePlayer.play();
+ * } catch(err) {
+ *     console.log("remotePlayer api failed with error code", err.code, err.msg);
+ * }
+ *
+ * @returns {RemotePlayer} pointer to the RemotePlayer singleton
+ */
+"needed for the module doc comment to be recognized";

package/src/interface/senzaShakaPlayer.js

@@ -0,0 +1,168 @@
+import * as shaka from "shaka-player";
+
+//  Define custom error category
+shaka.util.Error.Category.SENZA_PLAYER_ERROR = 50;
+shaka.util.Error.Code.SENZA_PLAYER_ERROR = 10500;
+
+// 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 {
+    /**
+     * 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.
+     */
+    constructor(videoElement, videoContainer, dependencyInjector) {
+        super(videoElement, videoContainer, dependencyInjector);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+   * 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) {
+        return super.detach(keepAdManager);
+    }
+
+    /**
+   * Unloads the currently playing stream, if any.
+   *
+   * @param {boolean=} initializeMediaSource
+   * @param {boolean=} keepAdManager
+   * @return {!Promise}
+   * @export
+   */
+    async unload(initializeMediaSource = true, keepAdManager = false) {
+        return 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 super.getTextLanguages();
+    }
+
+    /**
+     * Overrides the getAudioTracks method to use the remote player's audio tracks.
+     * @returns {Array} An array of audio tracks.
+     */
+    getAudioLanguages() {
+        return super.getAudioLanguages();
+    }
+
+    /**
+     * 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) {
+        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) {
+        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) {
+        super.setTextTrackVisibility(visible);
+    }
+
+    /**
+     * Helper function that makes it easier to check if lifecycle.state is
+     * either background or inTransitionToBackground.
+     */
+    get isInRemotePlayback() {
+        return false;
+    }
+
+    /**
+     * 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) {
+        return super.load(url, startTime, mimeType);
+    }
+
+    /***
+     * Destroys the player instance, cleaning up resources and event listeners.
+     * @returns {Promise<void>}
+     */
+    async destroy() {
+        return super.destroy();
+    }
+
+    /**
+     * 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) {
+        return super.configure(config);
+    }
+}
+
+senzaShaka.Player = SenzaShakaPlayer;
+export { senzaShaka as shaka };

package/src/interface/utils.js

@@ -0,0 +1,45 @@
+import pack from "../../package.json";
+const { version } = pack;
+
+/* eslint-disable no-console */
+class SdkLogger {
+
+    constructor(logFields) {
+        this.logFields = logFields;
+    }
+    debug(...data) {
+        console.debug(this.formatLogString(data));
+    }
+    log(...data) {
+        console.log(this.formatLogString(data));
+    }
+    info(...data) {
+        console.info(this.formatLogString(data));
+    }
+    warn(...data) {
+        console.warn(this.formatLogString(data));
+    }
+    error(...data) {
+        console.error(this.formatLogString(data));
+    }
+    metrics(metricObj) {
+        console.info(`[hs-sdk] [metrics] ${JSON.stringify(metricObj)}`);
+    }
+    withFields(logFields) {
+        return new SdkLogger({ ...this.logFields, ...logFields });
+    }
+    formatLogString(data) {
+        let logString = "[hs-sdk] " + data.join(" ");
+        if (this.logFields) {
+            logString += " [log-fields] " + JSON.stringify(this.logFields);
+        }
+        return logString;
+    }
+}
+
+export const sdkLogger = new SdkLogger({ sdkVersion: version });
+
+export function noop(functionname, ...args) {
+    console.log(`Called "${functionname}" with args:`, ...args || [], "This feature is only supported E2E.");
+    return Promise.resolve();
+}