@mediakind/mkplayer 1.5.0 → 1.7.0

package/types/classes/player/MKPlayer.js

@@ -0,0 +1,1160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MKPlayer = void 0;
+const MKUtils_1 = require("../common/MKUtils");
+const common_1 = require("../common");
+const MKBitmovinPlayer_1 = require("./MKBitmovinPlayer");
+const MKAzukiRequest_1 = require("../request/MKAzukiRequest");
+const enums_1 = require("../../enums");
+const constants_1 = require("../../constants");
+const request_1 = require("../request");
+const MKSecureUrlManager_1 = require("../common/MKSecureUrlManager");
+class MKPlayer extends common_1.MKEventBase {
+    constructor(videoContainer, playerConfig) {
+        var _a, _b;
+        super();
+        this.sourceLoaded = false;
+        this.headers = null;
+        this.playerConfig = playerConfig;
+        this.videoContainer = videoContainer;
+        this.thumbnailManager = new common_1.MKThumbnailManager();
+        if (playerConfig.events) {
+            Object.entries(playerConfig.events).forEach(([key, value]) => {
+                this.on(key, value);
+            });
+        }
+        common_1.MKLog.setLogLevel((_b = (_a = playerConfig.log) === null || _a === void 0 ? void 0 : _a.level) !== null && _b !== void 0 ? _b : enums_1.MKLogLevel.Debug);
+        console.log(`### MKPlayer v${constants_1.MKConstants.SDK_VERSION}`);
+    }
+    addCastMetadata(metadata) {
+        var _a;
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        if (metadata === 0) {
+            var beaconData = (_a = this.azukiRequest) === null || _a === void 0 ? void 0 : _a.getBeaconData();
+            const fullUrl = MKUtils_1.MKUtils.updateURLQueryParams(beaconData.requestUrl, beaconData.requestOptions.queryParams);
+            const castMetadata = {
+                type: 0,
+                interval: 30000,
+                url: fullUrl,
+                headers: {
+                    AuthorizationToken: beaconData.requestOptions.headers.AuthorizationToken,
+                    DeviceProfile: beaconData.requestOptions.headers.DeviceProfile,
+                },
+                beaconRequestBody: {
+                    beacon: {
+                        complete: beaconData.requestOptions.body.beacon.complete,
+                        inhome: beaconData.requestOptions.body.beacon.inhome,
+                        live: beaconData.requestOptions.body.beacon.isLive,
+                    }
+                }
+            };
+            return this.player.addCastMetadata(castMetadata);
+        }
+        return this.player.addCastMetadata(metadata);
+    }
+    addSubtitle(subtitleTrack) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.addSubtitle(subtitleTrack);
+    }
+    castStop() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.castStop();
+    }
+    castVideo() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.castVideo();
+    }
+    destroy() {
+        if (!this.player) {
+            return Promise.reject(new Error("Player not yet available!"));
+        }
+        return this.player.destroy();
+    }
+    disableSubtitle(subtitleID) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.disableSubtitle(subtitleID);
+    }
+    enableSubtitle(subtitleID) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.enableSubtitle(subtitleID);
+    }
+    getAspectRatio() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getAspectRatio();
+    }
+    getAudio() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getAudio();
+    }
+    getAudioQuality() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getAudioQuality();
+    }
+    getAvailableAudio() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return [];
+        }
+        return this.player.getAvailableAudio();
+    }
+    getAvailableAudioQualities() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return [];
+        }
+        return this.player.getAvailableAudioQualities();
+    }
+    getAvailableSubtitles() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return [];
+        }
+        return this.player.getAvailableSubtitles();
+    }
+    getAvailableVideoQualities() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return [];
+        }
+        return this.player.getAvailableVideoQualities();
+    }
+    getBufferLevel(type, media) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getBufferLevel(type, media);
+    }
+    getBufferedRanges() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return [];
+        }
+        return this.player.getBufferedRanges();
+    }
+    getVersion() {
+        return constants_1.MKConstants.SDK_VERSION;
+    }
+    getVideoContainer() {
+        if (!this.player)
+            return this.videoContainer;
+        return this.player.getVideoContainer();
+    }
+    getCurrentTime(mode) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getCurrentTime(mode);
+    }
+    getDownloadedAudioData() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getDownloadedAudioData();
+    }
+    getDownloadedVideoData() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getDownloadedVideoData();
+    }
+    getDroppedVideoFrames() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getDroppedVideoFrames();
+    }
+    getDuration() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getDuration();
+    }
+    getMaxTimeShift() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getMaxTimeShift();
+    }
+    getPlaybackAudioData() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getPlaybackAudioData();
+    }
+    getPlaybackSpeed() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getPlaybackSpeed();
+    }
+    getPlaybackVideoData() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getPlaybackVideoData();
+    }
+    getSeekableRange(mode) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getSeekableRange(mode);
+    }
+    getThumbnail(time) {
+        var _a;
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        if ((_a = this.sourceConfig) === null || _a === void 0 ? void 0 : _a.thumbnailTrack) {
+            return this.player.getThumbnail(time);
+        }
+        if (this.playerConfig.enableHlsImageMediaPlaylistSupport) {
+            return this.thumbnailManager.getThumbnail(time);
+        }
+        return null;
+    }
+    getTimeShift() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getTimeShift();
+    }
+    getTotalStalledTime() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getTotalStalledTime();
+    }
+    getVideoElement() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return undefined;
+        }
+        return this.player.getVideoElement();
+    }
+    getVideoQuality() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getVideoQuality();
+    }
+    getViewMode() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getViewMode();
+    }
+    getVolume() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getVolume();
+    }
+    hasEnded() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.hasEnded();
+    }
+    isAirplayActive() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isAirplayActive();
+    }
+    isAirplayAvailable() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isAirplayAvailable();
+    }
+    isCastAvailable() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isCastAvailable();
+    }
+    isCasting() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isCasting();
+    }
+    isLive() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isLive();
+    }
+    isMuted() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isMuted();
+    }
+    isPaused() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isPaused();
+    }
+    isPlaying() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isPlaying();
+    }
+    isStalled() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isStalled();
+    }
+    isViewModeAvailable(viewMode) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.isViewModeAvailable(viewMode);
+    }
+    load(sourceConfig, disableSeeking) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sourceLoaded) {
+                yield this.unload();
+            }
+            return new Promise((resolve, reject) => {
+                this.sourceLoaded = false;
+                this.azukiRequest = undefined;
+                this.sourceConfig = undefined;
+                this.programManager = undefined;
+                this.sessionManager = undefined;
+                this.secureUrlManager = undefined;
+                this.adobeSessionConcurrencyRequest = undefined;
+                sourceConfig = Object.assign({}, sourceConfig);
+                if (sourceConfig.ull !== undefined) {
+                    return reject(new Error("ULL source is not yet supported!"));
+                }
+                else if (sourceConfig.hls !== undefined || sourceConfig.dash !== undefined || sourceConfig.smooth !== undefined || sourceConfig.progressive !== undefined) {
+                    this.loadSource(sourceConfig, disableSeeking)
+                        .then(() => { return resolve(); })
+                        .catch((error) => { return reject(error); });
+                }
+                else if (sourceConfig.registered !== undefined) {
+                    if (sourceConfig.registered.environmentConfig.kssUrl) {
+                        this.secureUrlManager = new MKSecureUrlManager_1.MKSecureUrlManager(sourceConfig.registered.environmentConfig.authToken, sourceConfig.registered.environmentConfig.kssUrl);
+                    }
+                    this.azukiRequest = new MKAzukiRequest_1.MKAzukiRequest(sourceConfig, this.onSessionConcurrencyNotificationError.bind(this));
+                    this.azukiRequest.rollRequest()
+                        .then((rollInfo) => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b, _c;
+                        this.programManager = new common_1.MKProgramManager(this.azukiRequest);
+                        const controlBlockingRestrictions = this.programManager.validateProgramRestrictions(rollInfo.programInfo);
+                        if (controlBlockingRestrictions.length > 0) {
+                            this.emitProgramRestrictionsEvent(controlBlockingRestrictions);
+                        }
+                        if (rollInfo.asidInitToken && rollInfo.asidInitToken.length > 0) {
+                            const fmtsASiDEventData = {
+                                initToken: rollInfo.asidInitToken,
+                                assetId: rollInfo.mediaId,
+                                timestamp: MKUtils_1.MKUtils.getCurrentTimestamp(),
+                                type: enums_1.MKPlayerEvent.FMTSASiD,
+                            };
+                            this.emit(enums_1.MKPlayerEvent.FMTSASiD, fmtsASiDEventData);
+                        }
+                        if (rollInfo.programInfo.timeRange && rollInfo.isLive) {
+                            this.emitProgramTimeChangedEvent(rollInfo.programInfo.timeRange);
+                            (_a = this.programManager) === null || _a === void 0 ? void 0 : _a.updateProgramInfoList(rollInfo.programInfo);
+                        }
+                        if ((_b = sourceConfig.cdnOptions) === null || _b === void 0 ? void 0 : _b.cdnTokens) {
+                            rollInfo.sourceUrl = MKUtils_1.MKUtils.updateURLQueryParams(rollInfo.sourceUrl, sourceConfig.cdnOptions.cdnTokens);
+                        }
+                        if (this.secureUrlManager) {
+                            try {
+                                const signature = yield this.secureUrlManager.getSignature(rollInfo.sourceUrl);
+                                this.updateHttpHeaders({
+                                    "X-MK-Signature": signature,
+                                    "AuthorizationToken": (_c = sourceConfig.registered) === null || _c === void 0 ? void 0 : _c.environmentConfig.authToken
+                                });
+                            }
+                            catch (_d) {
+                                common_1.MKLog.warn("Failed to get signature from secureUrlManager!");
+                            }
+                        }
+                        if (rollInfo.analytics_publish_percent) {
+                            const randomDecimal = Math.random();
+                            const randomNumber = Math.floor(randomDecimal * 99) + 1;
+                            if (randomNumber >= rollInfo.analytics_publish_percent && !!this.playerConfig.analytics) {
+                                this.analyticsConfig = this.playerConfig.analytics;
+                                this.playerConfig.analytics = false;
+                                common_1.MKLog.warn(`Disabled Bitmovin Analytics session: Generated random number - ${randomNumber} is greater than threshold value - ${rollInfo.analytics_publish_percent}`);
+                            }
+                            else if (randomNumber < rollInfo.analytics_publish_percent && !this.playerConfig.analytics) {
+                                this.playerConfig.analytics = this.analyticsConfig;
+                                common_1.MKLog.log(`Enabled Bitmovin Analytics session: Generated random number - ${randomNumber} is lesser than threshold value - ${rollInfo.analytics_publish_percent}`);
+                            }
+                        }
+                        this.loadSource(this.updateSourceConfigFromRollInfo(sourceConfig, rollInfo), disableSeeking)
+                            .then(() => { return resolve(); })
+                            .catch((error) => { return reject(error); });
+                    }))
+                        .catch((error) => {
+                        return reject(this.unloadAndEmitErrorEvent(error, false));
+                    });
+                }
+                else {
+                    return reject(new Error("Source type not supported!"));
+                }
+            });
+        });
+    }
+    reload(start, sourceOptions) {
+        if (!this.player) {
+            return Promise.reject(new Error("Player not yet available!"));
+        }
+        return this.player.reload(start, sourceOptions);
+    }
+    mute(issuer) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.mute(issuer);
+    }
+    pause(issuer) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.pause(issuer);
+    }
+    play(issuer) {
+        if (!this.player) {
+            return Promise.reject(new Error("Player not yet available!"));
+        }
+        return this.player.play(issuer);
+    }
+    preload() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.preload();
+    }
+    removeSubtitle(subtitleID) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.removeSubtitle(subtitleID);
+    }
+    seek(time, issuer) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return false;
+        }
+        return this.player.seek(time, issuer);
+    }
+    seekToLiveEdge(issuer) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.seekToLiveEdge(issuer);
+    }
+    setAspectRatio(aspectratio) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setAspectRatio(aspectratio);
+    }
+    setAudio(trackID) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setAudio(trackID);
+    }
+    setAudioQuality(audioQualityID) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setAudioQuality(audioQualityID);
+    }
+    updateAuthToken(authToken) {
+        var _a;
+        if (!this.azukiRequest) {
+            common_1.MKLog.error("Available only for registered source and after source is loaded!");
+            return;
+        }
+        if (!!!authToken) {
+            common_1.MKLog.error("Given authToken is not valid!");
+            return;
+        }
+        this.azukiRequest.updateAuthToken(authToken);
+        (_a = this.secureUrlManager) === null || _a === void 0 ? void 0 : _a.updateAuthToken(authToken).then((signature) => {
+            var _a;
+            if (!!signature) {
+                this.updateHttpHeaders({
+                    "X-MK-Signature": signature,
+                    "AuthorizationToken": authToken
+                });
+                (_a = this.player) === null || _a === void 0 ? void 0 : _a.setHttpHeaders(this.headers);
+                this.thumbnailManager.setHttpHeaders(this.headers);
+            }
+        }).catch((_error) => {
+            common_1.MKLog.warn("Something went wrong while setting http headers on the player for secureUrl signature and authToken!");
+        });
+    }
+    setHttpHeaders(headers) {
+        var _a, _b;
+        if (headers === null) {
+            (_a = this.player) === null || _a === void 0 ? void 0 : _a.setHttpHeaders(headers);
+            this.headers = null;
+            return;
+        }
+        const authToken = MKUtils_1.MKUtils.pluckValue(headers, "AuthorizationToken");
+        if (this.azukiRequest && this.secureUrlManager && typeof (authToken) === "string" && !!authToken) {
+            this.azukiRequest.updateAuthToken(authToken);
+            this.secureUrlManager.updateAuthToken(authToken)
+                .then((signature) => {
+                var _a;
+                headers["X-MK-Signature"] = signature;
+                this.updateHttpHeaders(headers);
+                (_a = this.player) === null || _a === void 0 ? void 0 : _a.setHttpHeaders(this.headers);
+                this.thumbnailManager.setHttpHeaders(this.headers);
+            })
+                .catch((_) => {
+                var _a;
+                common_1.MKLog.warn("Failed to get signature for the new authToken, setting the given headers on the player anyway!");
+                this.updateHttpHeaders(headers);
+                (_a = this.player) === null || _a === void 0 ? void 0 : _a.setHttpHeaders(this.headers);
+                this.thumbnailManager.setHttpHeaders(this.headers);
+            });
+        }
+        else {
+            this.updateHttpHeaders(headers);
+            (_b = this.player) === null || _b === void 0 ? void 0 : _b.setHttpHeaders(this.headers);
+            this.thumbnailManager.setHttpHeaders(this.headers);
+        }
+    }
+    setInhomeStatus(inhomeStatus) {
+        MKAzukiRequest_1.MKAzukiRequest.inhomeStatus = inhomeStatus;
+    }
+    setLocationDetail(locationDetail) {
+        if (locationDetail) {
+            MKAzukiRequest_1.MKAzukiRequest.locationDetail = locationDetail;
+        }
+        else {
+            delete MKAzukiRequest_1.MKAzukiRequest.locationDetail;
+        }
+    }
+    setLogLevel(level) {
+        var _a;
+        common_1.MKLog.setLogLevel(level);
+        (_a = this.player) === null || _a === void 0 ? void 0 : _a.setLogLevel(level);
+    }
+    setPlaybackSpeed(speed) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setPlaybackSpeed(speed);
+    }
+    setPosterImage(url, keepPersistent) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setPosterImage(url, keepPersistent);
+    }
+    setTargetBufferLevel(type, value, media) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setTargetBufferLevel(type, value, media);
+    }
+    setVideoElement(videoElement) {
+        this.videoElement = videoElement;
+    }
+    setVideoQuality(videoQualityID) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setVideoQuality(videoQualityID);
+    }
+    setViewMode(viewMode, options) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setViewMode(viewMode, options);
+    }
+    setVolume(volume, issuer) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setVolume(volume, issuer);
+    }
+    showAirplayTargetPicker() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.showAirplayTargetPicker();
+    }
+    unload() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.player) {
+                return Promise.reject(new Error("Player not yet available!"));
+            }
+            (_a = this.sessionManager) === null || _a === void 0 ? void 0 : _a.stopSession().catch((error) => {
+                common_1.MKLog.warn("stopSession failed for sesison concurrency with error: ", JSON.stringify(error));
+            });
+            if (this.playerConfig.enableHlsImageMediaPlaylistSupport) {
+                this.thumbnailManager.disable();
+            }
+            if (this.videoElement) {
+                this.videoElement.src = "";
+                yield this.videoElement.setMediaKeys(null);
+            }
+            return this.player.unload();
+        });
+    }
+    unmute(issuer) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.unmute(issuer);
+    }
+    getCatchupConfig() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getCatchupConfig();
+    }
+    getFallbackConfig() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return null;
+        }
+        return this.player.getFallbackConfig();
+    }
+    getLatency() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getLatency();
+    }
+    getTargetLatency() {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return 0;
+        }
+        return this.player.getTargetLatency();
+    }
+    setCatchupConfig(config) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setCatchupConfig(config);
+    }
+    setFallbackConfig(config) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setFallbackConfig(config);
+    }
+    setTargetLatency(latency) {
+        if (!this.player) {
+            common_1.MKLog.error("Player not yet available!");
+            return;
+        }
+        this.player.setTargetLatency(latency);
+    }
+    updateHttpHeaders(headers) {
+        var _a;
+        if (headers === null) {
+            this.headers = null;
+        }
+        else {
+            this.headers = Object.assign({}, (_a = this.headers) !== null && _a !== void 0 ? _a : {}, headers);
+        }
+    }
+    updateSourceConfigFromRollInfo(sourceConfig, rollInfo) {
+        sourceConfig.drm = rollInfo.drm;
+        if (sourceConfig.assetType !== enums_1.MKAssetType.Catchup && sourceConfig.assetType !== enums_1.MKAssetType.DVR) {
+            sourceConfig.assetType = rollInfo.isLive ? (rollInfo.isLiveEvent ? enums_1.MKAssetType.Event : enums_1.MKAssetType.Live) : enums_1.MKAssetType.VOD;
+        }
+        if (rollInfo.streamType === enums_1.MKStreamType.Hls) {
+            sourceConfig.hls = rollInfo.sourceUrl;
+        }
+        else if (rollInfo.streamType === enums_1.MKStreamType.Dash) {
+            sourceConfig.dash = rollInfo.sourceUrl;
+        }
+        return sourceConfig;
+    }
+    initializeBitmovinPlayerEngine() {
+        this.player = new MKBitmovinPlayer_1.MKBitmovinPlayer(this.videoContainer, this.playerConfig);
+        this.addListeners();
+    }
+    initializePlayer(sourceConfig) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!sourceConfig)
+                    return reject(new Error("Invalid source configuration!"));
+                if (!!sourceConfig.hls || !!sourceConfig.dash || !!sourceConfig.smooth || !!sourceConfig.progressive) {
+                    if (this.player && !(this.player instanceof MKBitmovinPlayer_1.MKBitmovinPlayer)) {
+                        try {
+                            yield this.player.destroy();
+                        }
+                        catch (_a) {
+                        }
+                        this.player = undefined;
+                    }
+                    this.initializeBitmovinPlayerEngine();
+                    return resolve();
+                }
+                else if (sourceConfig.ull) {
+                    return reject(new Error("ULL source not yet supported!"));
+                }
+            }
+            catch (error) {
+                return reject(error);
+            }
+        }));
+    }
+    addListeners() {
+        if (this.player) {
+            this.player.on(enums_1.MKPlayerEvent.AdBreakFinished, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdBreakFinished, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdBreakStarted, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdBreakStarted, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdFinished, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdFinished, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdMarker, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdMarker, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdClickThrough, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdClickThrough, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdCompanion, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdCompanion, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdVerification, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdVerification, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdQuartile, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdQuartile, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AdStarted, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AdStarted, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AirplayAvailable, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AirplayAvailable, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AirplayChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AirplayChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AspectRatioChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AspectRatioChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioAdaptation, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioAdaptation, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioAdded, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioAdded, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioDownloadQualityChange, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChange, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioDownloadQualityChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioPlaybackQualityChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioPlaybackQualityChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioQualityAdded, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioQualityAdded, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioQualityChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioQualityChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioQualityRemoved, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioQualityRemoved, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.AudioRemoved, (event) => {
+                this.emit(enums_1.MKPlayerEvent.AudioRemoved, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.CastAvailable, (event) => {
+                this.emit(enums_1.MKPlayerEvent.CastAvailable, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.CastStart, (event) => {
+                this.emit(enums_1.MKPlayerEvent.CastStart, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.CastStarted, (event) => {
+                if (this.sessionManager) {
+                    this.addCastMetadata(this.sessionManager.sessionManager === "azuki" ? 0 : 1);
+                }
+                this.emit(enums_1.MKPlayerEvent.CastStarted, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.CastStopped, (event) => {
+                this.emit(enums_1.MKPlayerEvent.CastStopped, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.CastWaitingForDevice, (event) => {
+                this.emit(enums_1.MKPlayerEvent.CastWaitingForDevice, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.CueEnter, (event) => {
+                this.emit(enums_1.MKPlayerEvent.CueEnter, event);
+            }),
+                this.player.on(enums_1.MKPlayerEvent.CueExit, (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CueExit, event);
+                }),
+                this.player.on(enums_1.MKPlayerEvent.CueParsed, (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CueParsed, event);
+                }),
+                this.player.on(enums_1.MKPlayerEvent.CueUpdate, (event) => {
+                    this.emit(enums_1.MKPlayerEvent.CueUpdate, event);
+                }),
+                this.player.on(enums_1.MKPlayerEvent.DVRWindowExceeded, (event) => {
+                    this.emit(enums_1.MKPlayerEvent.DVRWindowExceeded, event);
+                });
+            this.player.on(enums_1.MKPlayerEvent.Destroy, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Destroy, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.DownloadFinished, (event) => {
+                this.emit(enums_1.MKPlayerEvent.DownloadFinished, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.DrmLicenseAdded, (event) => {
+                this.emit(enums_1.MKPlayerEvent.DrmLicenseAdded, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.DurationChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.DurationChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Error, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Error, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.LatencyModeChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.LatencyModeChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Metadata, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Metadata, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.MetadataChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.MetadataChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.MetadataParsed, (event) => {
+                this.emit(enums_1.MKPlayerEvent.MetadataParsed, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Muted, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Muted, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Paused, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Paused, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.PeriodSwitch, (event) => {
+                this.emit(enums_1.MKPlayerEvent.PeriodSwitch, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.PeriodSwitched, (event) => {
+                this.emit(enums_1.MKPlayerEvent.PeriodSwitched, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Play, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Play, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.PlaybackFinished, (event) => {
+                this.emit(enums_1.MKPlayerEvent.PlaybackFinished, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.PlaybackSpeedChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.PlaybackSpeedChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.PlayerResized, (event) => {
+                this.emit(enums_1.MKPlayerEvent.PlayerResized, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Playing, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Playing, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Ready, (event) => {
+                this.videoElement = this.getVideoElement();
+                this.emit(enums_1.MKPlayerEvent.Ready, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Seek, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Seek, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.Seeked, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Seeked, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SegmentPlayback, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SegmentPlayback, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SegmentRequestFinished, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SegmentRequestFinished, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.ShowAirplayTargetPicker, (event) => {
+                this.emit(enums_1.MKPlayerEvent.ShowAirplayTargetPicker, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SourceLoaded, (event) => {
+                var _a, _b, _c, _d, _e, _f;
+                this.sourceLoaded = true;
+                this.emit(enums_1.MKPlayerEvent.SourceLoaded, event);
+                if ((_b = (_a = this.sourceConfig) === null || _a === void 0 ? void 0 : _a.registered) === null || _b === void 0 ? void 0 : _b.adobePrimetimeConfig) {
+                    try {
+                        this.adobeSessionConcurrencyRequest = new request_1.MKAdobeSessionConcurrencyRequest(this.sourceConfig.registered.adobePrimetimeConfig, this.onSessionConcurrencyNotificationError.bind(this));
+                        this.sessionManager = this.adobeSessionConcurrencyRequest;
+                    }
+                    catch (error) {
+                        common_1.MKLog.warn("Failed to initialize session manager due to error: ", JSON.stringify(error));
+                    }
+                }
+                else {
+                    this.sessionManager = this.azukiRequest;
+                }
+                (_c = this.sessionManager) === null || _c === void 0 ? void 0 : _c.startSession().catch((error) => {
+                    common_1.MKLog.warn("startSession failed for session concurrency with error: ", JSON.stringify(error));
+                });
+                if (this.playerConfig.enableHlsImageMediaPlaylistSupport &&
+                    ((_d = this.sourceConfig) === null || _d === void 0 ? void 0 : _d.hls) && !((_e = this.sourceConfig) === null || _e === void 0 ? void 0 : _e.thumbnailTrack)) {
+                    this.thumbnailManager.enable(this.sourceConfig.hls, (_f = this.headers) !== null && _f !== void 0 ? _f : undefined);
+                }
+            });
+            this.player.on(enums_1.MKPlayerEvent.SourceUnloaded, (event) => {
+                this.sourceLoaded = false;
+                this.emit(enums_1.MKPlayerEvent.SourceUnloaded, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.StallEnded, (event) => {
+                this.emit(enums_1.MKPlayerEvent.StallEnded, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.StallStarted, (event) => {
+                this.emit(enums_1.MKPlayerEvent.StallStarted, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SubtitleAdded, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SubtitleAdded, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SubtitleDisable, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SubtitleDisable, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SubtitleDisabled, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SubtitleDisabled, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SubtitleEnable, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SubtitleEnable, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SubtitleEnabled, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SubtitleEnabled, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.SubtitleRemoved, (event) => {
+                this.emit(enums_1.MKPlayerEvent.SubtitleRemoved, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.TargetLatencyChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.TargetLatencyChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.TimeChanged, (event) => {
+                var _a;
+                this.emit(enums_1.MKPlayerEvent.TimeChanged, event);
+                const timeChangedEvent = event;
+                if (this.programManager && ((_a = this.sourceConfig) === null || _a === void 0 ? void 0 : _a.assetType) === enums_1.MKAssetType.Live) {
+                    const programInfo = this.programManager.checkProgramBoundary(timeChangedEvent.time);
+                    if (programInfo) {
+                        try {
+                            const controlBlockingRestrictions = this.programManager.validateProgramRestrictions(programInfo);
+                            if (controlBlockingRestrictions.length > 0) {
+                                this.emitProgramRestrictionsEvent(controlBlockingRestrictions);
+                            }
+                            if (programInfo.timeRange) {
+                                this.emitProgramTimeChangedEvent(programInfo.timeRange);
+                            }
+                        }
+                        catch (error) {
+                            if (MKUtils_1.MKUtils.isMKError(error)) {
+                                this.unloadAndEmitErrorEvent(error);
+                            }
+                            else {
+                                common_1.MKLog.error("Unhandled error: ", error);
+                            }
+                        }
+                    }
+                }
+            });
+            this.player.on(enums_1.MKPlayerEvent.Unmuted, (event) => {
+                this.emit(enums_1.MKPlayerEvent.Unmuted, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoAdaptation, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VideoAdaptation, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoDownloadQualityChange, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChange, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoDownloadQualityChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoPlaybackQualityChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VideoPlaybackQualityChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoQualityAdded, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VideoQualityAdded, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoQualityChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VideoQualityChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoQualityRemoved, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VideoQualityRemoved, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.ViewModeChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.ViewModeChanged, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VolumeChanged, (event) => {
+                this.emit(enums_1.MKPlayerEvent.VolumeChanged, event);
+            });
+        }
+    }
+    emitProgramTimeChangedEvent(timeRange) {
+        const programTimeChangedEventData = {
+            timeRange: timeRange,
+            type: enums_1.MKPlayerEvent.ProgramTimeChanged,
+            timestamp: MKUtils_1.MKUtils.getCurrentTimestamp()
+        };
+        this.emit(enums_1.MKPlayerEvent.ProgramTimeChanged, programTimeChangedEventData);
+    }
+    unloadAndEmitErrorEvent(error, unloadPlayer = true) {
+        if (unloadPlayer)
+            this.unload();
+        const errorEvent = {
+            name: error.name,
+            code: error.code,
+            message: error.message,
+            type: enums_1.MKPlayerEvent.Error,
+            timestamp: MKUtils_1.MKUtils.getCurrentTimestamp()
+        };
+        this.emit(enums_1.MKPlayerEvent.Error, errorEvent);
+        return errorEvent;
+    }
+    emitProgramRestrictionsEvent(restrictions) {
+        if (restrictions.length > 0) {
+            const event = {
+                type: enums_1.MKPlayerEvent.ProgramRestrictions,
+                timestamp: MKUtils_1.MKUtils.getCurrentTimestamp(),
+                programRestrictions: restrictions,
+            };
+            this.emit(enums_1.MKPlayerEvent.ProgramRestrictions, event);
+        }
+    }
+    loadSource(sourceConfig, disableSeeking) {
+        return new Promise((resolve, reject) => {
+            this.initializePlayer(sourceConfig)
+                .then(() => {
+                this.sourceConfig = sourceConfig;
+                if (this.player) {
+                    if (this.videoElement) {
+                        this.player.setVideoElement(this.videoElement);
+                    }
+                    this.player.setHttpHeaders(this.headers);
+                    this.player.load(this.sourceConfig, disableSeeking)
+                        .then(() => { return resolve(); })
+                        .catch((error) => { return reject(error); });
+                }
+                else {
+                    return reject(new Error("Invalid player instance!"));
+                }
+            })
+                .catch((error) => {
+                return reject(error);
+            });
+        });
+    }
+    onSessionConcurrencyNotificationError(error) {
+        var _a;
+        const errorCodes = [
+            "4-63-2430",
+            "4-63-3736",
+            "4-81-409",
+        ];
+        if (errorCodes.includes(error.code)) {
+            (_a = this.sessionManager) === null || _a === void 0 ? void 0 : _a.stopSession().catch((error) => {
+                common_1.MKLog.warn("stopSession failed for sesison concurrency with error: ", JSON.stringify(error));
+            });
+            this.unloadAndEmitErrorEvent(error, true);
+        }
+        else {
+            common_1.MKLog.warn("Session concurrency notification failed with error: ", JSON.stringify(error));
+        }
+    }
+}
+exports.MKPlayer = MKPlayer;
+//# sourceMappingURL=MKPlayer.js.map