senza-sdk 4.4.1-4ca75a1.0 → 4.4.1

package/dist/implementation.bundle.js.LICENSE.txt

@@ -0,0 +1,82 @@
+/*
+ @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
+ Copyright 2013 Ali Al Dallal
+
+ Licensed under the MIT license.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+*/
+
+/*
+ @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
+ Shaka Player
+ Copyright 2025 Google LLC
+ SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+ @license
+ tXml
+ Copyright 2015 Tobias Nickel
+ SPDX-License-Identifier: MIT
+*/
+
+//! moment.js
+
+//! moment.js locale configuration

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "senza-sdk",
-    "version": "4.4.1-4ca75a1.0",
+    "version": "4.4.1",
     "main": "./src/api.js",
     "description": "API for Senza application",
     "license": "MIT",
@@ -53,15 +53,15 @@
                 "statements": 93.46
             },
             "src/interface": {
-                "branches": 68.42,
-                "functions": 39.63,
-                "lines": 64.94,
-                "statements": 65.32
+                "branches": 63.9,
+                "functions": 39.28,
+                "lines": 64.61,
+                "statements": 65
             }
         }
     },
     "dependencies": {
-        "shaka-player": "^4.12.5",
+        "shaka-player": "4.15.8",
         "moment": "^2.30.1"
     }
 }

package/src/api.js

@@ -308,6 +308,9 @@ let ShakaPlayerImplementation;
 let shakaImplementation;
 
 if (!isRunningE2E()) {
+    // ------------------------------------------------------------------------------------------------
+    // -- Do NOT change this log, as ui-streamer is checking this string to detect abnormal behavior --
+    // ------------------------------------------------------------------------------------------------
     sdkLogger.warn("Senza SDK is not running in E2E environment. Some features may not work as expected.");
 
     lifecycle = new Lifecycle();

package/src/implementation/lifecycle.js

@@ -559,7 +559,8 @@ class Lifecycle extends LifecycleInterface {
                     action: "play",
                     fcid: FCID,
                     audioLanguage,
-                    subtitlesLanguage
+                    subtitlesLanguage,
+                    autoTune: remotePlayer._autoTune
                 };
                 if (this._remotePlayerApiVersion >= 2) {
                     message.type = "remotePlayer.play";
@@ -579,7 +580,7 @@ class Lifecycle extends LifecycleInterface {
                     }
                     request = message;
                 }
-                logger.log(`lifecycle moveToBackground: sending play action audioLanguage=${message.audioLanguage} subtitlesLanguage=${message.subtitlesLanguage} textTrackVisibility=${remotePlayer.textTrackVisibility}`);
+                logger.log(`lifecycle moveToBackground: sending play action audioLanguage=${message.audioLanguage} subtitlesLanguage=${message.subtitlesLanguage} textTrackVisibility=${remotePlayer.textTrackVisibility} autoTune=${remotePlayer._autoTune}`);
                 let timerId = 0;
                 const timeBeforeSendingRequest = Date.now();
                 const queryId = window.cefQuery({

package/src/implementation/remotePlayer.js

@@ -183,6 +183,7 @@ class RemotePlayer extends RemotePlayerInterface {
             }
         }
         this._loadMode = playerState?.isLoaded ? this.LoadMode.LOADED : this.LoadMode.NOT_LOADED;
+        this._autoTune = false;
 
         this._isPlaying = window?.sessionStorage?.getItem("senzaSdk_isPlaying") === "true";
 
@@ -196,6 +197,8 @@ class RemotePlayer extends RemotePlayerInterface {
         this._remotePlayerConfirmationTimeout = uiStreamerSettings?.remotePlayerConfirmationTimeout ?? DEFAULT_REMOTE_PLAYER_CONFIRMATION_TIMEOUT;
         this._remotePlayerApiVersion = uiStreamerSettings?.remotePlayerApiVersion || 1;
         this._multiSeekDelay = uiStreamerSettings?.multiSeekDelay || MULTI_SEEK_DELAY_MSEC;
+        this._uiAvSyncIntervalMs = uiStreamerSettings?.uiAvSyncIntervalMs;
+        this._abrAvSyncIntervalMs = uiStreamerSettings?.abrAvSyncIntervalMs;
         this._deviceAppVersion = sessionObj?.manifest?.["device-app"] || "";
 
         sdkLogger.info(`remotePLayer isPlaying=${this._isPlaying}`);
@@ -208,6 +211,7 @@ class RemotePlayer extends RemotePlayerInterface {
         }
         this._availabilityStartTime = playbackMetadata.availabilityStartTime;
         this._updateTracks(playbackMetadata);
+
     }
 
     /**
@@ -785,6 +789,12 @@ class RemotePlayer extends RemotePlayerInterface {
                     playbackPosition,
                     fcid: FCID
                 };
+                if (this._uiAvSyncIntervalMs !== undefined) {
+                    message.uiAvSyncIntervalMs = this._uiAvSyncIntervalMs;
+                }
+                if (this._abrAvSyncIntervalMs !== undefined) {
+                    message.abrAvSyncIntervalMs = this._abrAvSyncIntervalMs;
+                }
                 if (this._remotePlayerApiVersion >= 2) {
                     message.type = "remotePlayer.load";
                     message.class = "remotePlayer";
@@ -924,10 +934,11 @@ class RemotePlayer extends RemotePlayerInterface {
      * remotePlayer.play();
      * lifecycle.moveToBackground();
      *
+     * @param {boolean} [autoTune=false] Should be true when the play was triggered automatically by the app and not by a user action.
      * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg
      */
-    play() {
+    play(autoTune = false) {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call play() if remote player is not initialized");
         }
@@ -938,6 +949,7 @@ class RemotePlayer extends RemotePlayerInterface {
         }
 
         this._changePlayMode(true);
+        this._autoTune = autoTune;
 
         if (this._isSetAudioInProgress) {
             sdkLogger.info("application requesting play during setAudioLanguage");
@@ -1091,24 +1103,30 @@ class RemotePlayer extends RemotePlayerInterface {
      * @throws {RemotePlayerError} If the player is not initialized or not loaded.
      **/
     selectAudioTrack(audioTrackId) {
+        return this._selectAudioTrack(audioTrackId, false);
+    }
+
+    _selectAudioTrack(audioTrackId, force = false) {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call selectAudioTrack() if remote player is not initialized");
         }
         if (this._loadMode !== this.LoadMode.LOADED) {
             throw new RemotePlayerError(6001, "Cannot call selectAudioTrack() if remote player is not loaded");
         }
-        let found = false;
-        const prevSelectedAudioTrack = this._selectedAudioTrack;
-        for (const track of this.getAudioTracks()) {
-            if (track.id === audioTrackId) {
-                found = true;
-                break;
+        if (!force) {
+            let found = false;
+            for (const track of this.getAudioTracks()) {
+                if (track.id === audioTrackId) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                sdkLogger.warn(`Invalid audioTrackId ${audioTrackId}`);
+                return Promise.resolve();
             }
         }
-        if (!found) {
-            sdkLogger.warn(`Invalid audioTrackId ${audioTrackId}`);
-            return Promise.resolve();
-        }
+        const prevSelectedAudioTrack = this._selectedAudioTrack;
         if (this._selectedAudioTrack === audioTrackId) {
             return Promise.resolve(); // Audio language already selected
         }
@@ -1125,6 +1143,12 @@ class RemotePlayer extends RemotePlayerInterface {
         }
     }
 
+    async selectAudioLanguage(language, role="", accessibilityPurposeCode=this.AccessibilityPurposeCode.NONE) {
+        const trackId = this._generateSenzaTrackId(language, role, accessibilityPurposeCode);
+        return this._selectAudioTrack(trackId, true);
+    }
+
+
     /**
      * Handles the asynchronous selection of an audio track.
      * If the player is playing, it pauses before changing the track and resumes playback if necessary.
@@ -1218,6 +1242,11 @@ class RemotePlayer extends RemotePlayerInterface {
         return Promise.resolve(undefined);
     }
 
+    async selectTextLanguage(language, role="", accessibilityPurposeCode=this.AccessibilityPurposeCode.NONE) {
+        const trackId = this._generateSenzaTrackId(language, role, accessibilityPurposeCode);
+        return this._selectTextTrack(trackId, true);
+    }
+
     /** Select a specific text (subtitle) track.
      * Track id should come from a call to getTextTracks.
      * If no tracks exist - this is a no-op.
@@ -1227,24 +1256,31 @@ class RemotePlayer extends RemotePlayerInterface {
      * @throws {RemotePlayerError} If the player is not initialized or not loaded.
      * */
     selectTextTrack(textTrackId) {
+        return this._selectTextTrack(textTrackId, false);
+    }
+
+    _selectTextTrack(textTrackId, force = false) {
         if (!this._isInitialized) {
             throw new RemotePlayerError(6500, "Cannot call selectTextTrack() if remote player is not initialized");
         }
         if (this._loadMode !== this.LoadMode.LOADED) {
             throw new RemotePlayerError(6001, "Cannot call selectTextTrack() if remote player is not loaded");
         }
-        let found = false;
-        const prevSelectedTextTrack = this._selectedSubtitlesTrack;
-        for (const track of this.getTextTracks()) {
-            if (track.id === textTrackId) {
-                found = true;
-                break;
+        if (!force) {
+            let found = false;
+            for (const track of this.getTextTracks()) {
+                if (track.id === textTrackId) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                sdkLogger.warn(`Invalid textTrackId ${textTrackId}`);
+                return Promise.resolve();
             }
         }
-        if (!found) {
-            sdkLogger.warn(`Invalid textTrackId ${textTrackId}`);
-            return Promise.resolve();
-        }
+
+        const prevSelectedTextTrack = this._selectedSubtitlesTrack;
         if (this._selectedSubtitlesTrack === textTrackId) {
             return Promise.resolve(); // Subtitle language already selected
         }
@@ -1640,11 +1676,10 @@ class RemotePlayer extends RemotePlayerInterface {
         // In case where we aborted (new load or unload called), we don't want to resume playback.
         if (!this._abortSeeking) {
             if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_UI) {
-                if (!this._isAudioSyncEnabled()) {
-                    return Promise.resolve(true);
+                // When in foreground back from ABR, we are considered playing. But, if AIU is not enabled, we shouldn't resume it.
+                if (this._isAudioSyncEnabled()) {
+                    this._play(StreamType.AUDIO);
                 }
-                // resume audio play only if _isAudioSyncEnabled
-                this._play(StreamType.AUDIO);
             } else if (this._targetSeekPlayingState === TargetPlayingState.PLAYING_ABR) {
                 lifecycle._moveToBackground();
             }
@@ -1788,6 +1823,12 @@ class RemotePlayer extends RemotePlayerInterface {
         return setLanguageError ? Promise.reject(setLanguageError) : Promise.resolve();
     }
 
+    _generateSenzaTrackId(language, role, accessibilityPurpose) {
+        const l = language || "";
+        const r = role || "";
+        const ap = accessibilityPurpose || "";
+        return `${l}:${r}:${ap}`;
+    }
     _setScreenBlackout(blackoutTime) {
         if (window.cefQuery) {
             const FCID = getFCID();

package/src/implementation/senzaShakaPlayer.js

@@ -1,10 +1,9 @@
 import { SenzaShakaPlayer as SenzaShakaInterface, shaka } from "../interface/senzaShakaPlayer";
-
+import * as shakaDebug from "shaka-player/dist/shaka-player.compiled.debug.js";
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
-import { sdkLogger, iso6393to1 } from "./utils";
+import { sdkLogger } from "./utils";
 import moment from "moment";
 
-
 //  Define custom error category
 shaka.util.Error.Category.SENZA_PLAYER_ERROR = 50;
 shaka.util.Error.Code.SENZA_PLAYER_ERROR = 10500;
@@ -32,7 +31,6 @@ class SenzaError extends shaka.util.Error {
     }
 }
 
-
 export class SenzaShakaPlayer extends SenzaShakaInterface {
     /** @private {SenzaShakaPlayer|null} Previous instance of the player */
     static _prevInstance = null;
@@ -134,7 +132,7 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
                 this.videoElement.play();
             }
         },
-        "seeked" : () => {
+        "seeked": () => {
             // In case of background seek - we need to pause the local player after "seeked" until remote player is "playing" to avoid difference between the players.
             if (this.isInRemotePlayback) {
                 this._pauseForDelayedSeek = true;
@@ -164,57 +162,57 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         },
         "license-request": async (event) => {
             sdkLogger.log("remotePlayer", "license-request", "Got license-request event from remote player");
+            let responseBody = "Unknown Error";
+            let status = 500;
 
-            // 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",
-                originatesFromRemotePlayer: true
-            };
+            try {
 
-            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+                if (!this?.getConfiguration()?.drm?.servers?.["com.widevine.alpha"]) {
+                    status = 400;
+                    responseBody = "Missing Widevine license server";
+                    sdkLogger.warn("remotePlayer", "license-request", "missing Widevine license server");
+                    return; // the finally will send the response
+                }
+                // Extract license body from event
+                const requestBuffer = event?.detail?.licenseRequest;
+                if (!requestBuffer) {
+                    status = 400;
+                    responseBody = "Missing license request buffer";
+                    sdkLogger.warn("remotePlayer", "license-request", "missing license request buffer");
+                    return; // the finally will send the response
+                }
+                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));
 
-            let responseBody = response.data;
-            if (response.status < 200 || response.status >= 300) {
-                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);
+                const request = {
+                    body: licenseRequestBytes.buffer,
+                    uris: [this.getConfiguration().drm.servers["com.widevine.alpha"]],
+                    method: "POST",
+                    originatesFromRemotePlayer: true
+                };
 
-        },
-        "tracksupdate": () => {
-            this._audioTracksMap = {};
-            this._textTracksMap = {};
-            // create a map between language code and track id to be used for selection. If the language appears more than once the last one will be taken.
-            const audioTracks = remotePlayer.getAudioTracks();
-            for (const track of audioTracks) {
-                let lang = track.lang;
-
-                if (lang.length === 3) {
-                    lang = iso6393to1[lang] || lang;
-                }
-                this._audioTracksMap[lang] = track.id;
-            }
+                const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
 
-            const textTracks = remotePlayer.getTextTracks();
-            for (const track of textTracks) {
-                if (!track.autoTranslate) {
-                    let lang = track.lang;
+                responseBody = response.data;
+                status = response.status;
 
-                    if (lang.length === 3) {
-                        lang = iso6393to1[lang] || lang;
-                    }
-                    this._textTracksMap[lang] = track.id;
+                if (status < 200 || status >= 300) {
+                    responseBody = response.data ?? String.fromCharCode(new Uint8Array(response.data));
+                    sdkLogger.error("remotePlayer", "license-request", "failed to to get response from widevine:", status, responseBody);
                 }
+            } catch (error) {
+                sdkLogger.error("remotePlayer", "license-request", "License request failed:", error);
+                // For network errors, the error.data array contains [uri, status, responseText, ...]
+                status = error?.data?.[1] ?? 500;
+                responseBody = error?.data?.[2] ?? `Error response: ${error.message || error.toString()}`;
+                sdkLogger.error("remotePlayer", "license-request", "failed to get response from widevine:", status, responseBody);
+            } finally {
+                // Write response to remote player
+                sdkLogger.log("remotePlayer", "license-request", "Writing response to remote player", status);
+                event.writeLicenseResponse(status, responseBody);
             }
+
         },
         "playing": async () => {
             sdkLogger.info("remotePlayer playing event received");
@@ -453,8 +451,6 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         }
 
         await super.detach(keepAdManager);
-        this._audioTracksMap = {};
-        this._textTracksMap = {};
         this._removeVideoElementEventListeners();
         try {
             if (remotePlayer.getAssetUri() !== "") {
@@ -484,30 +480,65 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
     }
 
     getTextLanguages() {
-        return Object.keys(this._textTracksMap);
+        const tracks = this.remotePlayer.getTextTracks();
+        return [...new Set(tracks.map(item => item.lang))];
     }
 
     getAudioLanguages() {
-        return Object.keys(this._audioTracksMap);
+        const tracks = this.remotePlayer.getAudioTracks();
+        return [...new Set(tracks.map(item => item.lang))];
+    }
+
+
+    selectVariantTrack(track, clearBuffer = false, safeMargin = 0) {
+        const audioLang = track.language;
+        const audioRole = Array.isArray(track.audioRoles) && track.audioRoles.length > 0
+            ? track.audioRoles[0]
+            : null;
+        const audioId = track.audioId;
+        sdkLogger.log(`selectVariantTrack() called: audio id ${audioId} language ${audioLang}, role ${audioRole}, accessibilityPurpose: ${track.accessibilityPurpose}`);
+
+        const apCode = this._getAccessibilityCodeFromPurpose(track.accessibilityPurpose);
+        remotePlayer.selectAudioLanguage(audioLang, audioRole, apCode);
+
+        super.selectVariantTrack(track, clearBuffer, safeMargin);
+
+    }
+
+    selectAudioTrack(audioTrack, safeMargin = 0) {
+        const audioId = audioTrack.id;
+        const audioLang = audioTrack.language;
+        const role = Array.isArray(audioTrack.roles) && audioTrack.roles.length > 0
+            ? audioTrack.roles[0]
+            : null;
+        sdkLogger.log(`selectAudioTrack() called: audio id ${audioId} language ${audioLang}, role ${role}, accessibilityPurpose: ${audioTrack.accessibilityPurpose}`);
+        const apCode = this._getAccessibilityCodeFromPurpose(audioTrack.accessibilityPurpose);
+        remotePlayer.selectAudioLanguage(audioLang, role, apCode);
+
+        super.selectAudioTrack(audioTrack, safeMargin);
     }
 
     selectAudioLanguage(language, role) {
-        sdkLogger.log("Selecting audio language:", language, "with role: ", role);
-        if (this._audioTracksMap[language]) {
-            remotePlayer.selectAudioTrack(this._audioTracksMap[language]);
-        } else {
-            sdkLogger.warn(`Language ${language} not found in audio tracks map`);
-        }
+        sdkLogger.log("selectAudioLanguage() Selecting audio language:", language, "with role: ", role);
+        remotePlayer.selectAudioLanguage(language, role);
         super.selectAudioLanguage(language, role);
     }
 
+    selectTextTrack(textTrack) {
+        const textId = textTrack.id;
+        const textLang = textTrack.language;
+        const role = Array.isArray(textTrack.roles) && textTrack.roles.length > 0
+            ? textTrack.roles[0]
+            : null;
+        sdkLogger.log(`selectTextTrack() called: text id ${textId} language ${textLang}, role ${role}, accessibilityPurpose: ${textTrack.accessibilityPurpose}`);
+        const apCode = this._getAccessibilityCodeFromPurpose(textTrack.accessibilityPurpose);
+        remotePlayer.selectTextLanguage(textLang, role, apCode);
+
+        super.selectTextTrack(textTrack);
+    }
     selectTextLanguage(language, role) {
-        sdkLogger.log("Selecting text language:", language, "with role:", role);
-        if (this._textTracksMap[language]) {
-            remotePlayer.selectTextTrack(this._textTracksMap[language]);
-        } else {
-            sdkLogger.warn(`Language ${language} not found in text tracks map`);
-        }
+        sdkLogger.log("selectTextLanguage() Selecting text language:", language, "with role: ", role);
+        remotePlayer.selectTextLanguage(language, role);
         super.selectTextLanguage(language, role);
     }
 
@@ -734,7 +765,6 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         };
 
         if (!this.isInRemotePlayback || remotePlayer.getAssetUri() !== url) {
-            this._audioTracksMap = {};
             this._videoTracksMap = {};
             try {
                 if (this.remotePlayer.getLoadMode() === this.remotePlayer.LoadMode.UNLOADING) {
@@ -789,6 +819,32 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         }
     }
 
+    /**
+     * Returns accessibility code of Shaka's accessibility purpose string
+     * @param {string} purpose
+     * @returns {null|string}
+     * @private
+     */
+    _getAccessibilityCodeFromPurpose(purpose) {
+        switch (purpose) {
+        case shakaDebug.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED:
+            return remotePlayer.AccessibilityPurposeCode.VISUALLY_IMPAIRED;
+        case shakaDebug.media.ManifestParser.AccessibilityPurpose.HARD_OF_HEARING:
+            return remotePlayer.AccessibilityPurposeCode.HARD_OF_HEARING;
+        case shakaDebug.media.ManifestParser.AccessibilityPurpose.SPOKEN_SUBTITLES:
+            return remotePlayer.AccessibilityPurposeCode.SPOKEN_SUBTITLES;
+        case undefined:
+        case null:
+        case "":
+            return remotePlayer.AccessibilityPurposeCode.NONE;
+        default:
+            sdkLogger.warn(`_getAccessibilityCodeFromPurpose(): unknown accessibilityPurpose ${purpose}`);
+            return remotePlayer.AccessibilityPurposeCode.NONE;
+        }
+
+    }
+
+
 }
 
 shaka.Player = SenzaShakaPlayer;