@mediakind/mkplayer 1.6.0 → 1.8.0

package/types/classes/player/MKPlayer.js

@@ -1,4 +1,19 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 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) {
@@ -8,223 +23,293 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 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 MKUtils_1 = require("../common/MKUtils");
+var common_1 = require("../common");
+var MKBitmovinPlayer_1 = require("./MKBitmovinPlayer");
+var MKAzukiRequest_1 = require("../request/MKAzukiRequest");
+var enums_1 = require("../../enums");
+var constants_1 = require("../../constants");
+var request_1 = require("../request");
+var MKSecureUrlManager_1 = require("../common/MKSecureUrlManager");
+var MKPlayer = (function (_super) {
+    __extends(MKPlayer, _super);
+    function MKPlayer(videoContainer, playerConfig) {
+        var _this = this;
         var _a, _b;
-        super();
-        this.sourceLoaded = false;
-        this.headers = null;
-        this.playerConfig = playerConfig;
-        this.videoContainer = videoContainer;
-        this.thumbnailManager = new common_1.MKThumbnailManager();
+        _this = _super.call(this) || this;
+        _this.sourceLoaded = false;
+        _this.headers = null;
+        _this.playerConfig = playerConfig;
+        _this.videoContainer = videoContainer;
+        _this.thumbnailManager = new common_1.MKThumbnailManager();
+        _this.failOverUrl = '';
+        _this.cdnFailoverAttempted = false;
         if (playerConfig.events) {
-            Object.entries(playerConfig.events).forEach(([key, value]) => {
-                this.on(key, value);
+            Object.entries(playerConfig.events).forEach(function (_a) {
+                var key = _a[0], value = _a[1];
+                _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}`);
+        console.log("### MKPlayer v".concat(constants_1.MKConstants.SDK_VERSION));
+        return _this;
     }
-    addCastMetadata(metadata) {
+    MKPlayer.prototype.addCastMetadata = function (metadata) {
+        var _a, _b;
         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();
+            var fullUrl = MKUtils_1.MKUtils.updateURLQueryParams(beaconData.requestUrl, beaconData.requestOptions.queryParams);
+            var 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);
+        }
+        else if (metadata === 1) {
+            var adobePrimeTimeConfig = (_b = this.azukiRequest) === null || _b === void 0 ? void 0 : _b.getAdobeData();
+            var castMetadata = {
+                type: 1,
+                isProduction: adobePrimeTimeConfig.isProduction,
+                applicationId: adobePrimeTimeConfig.applicationId,
+                requesterId: adobePrimeTimeConfig.requesterId,
+                resourceId: adobePrimeTimeConfig.resourceId,
+                userId: adobePrimeTimeConfig.userId,
+                upStreamUserId: adobePrimeTimeConfig.upstreamUserId,
+                slmt: adobePrimeTimeConfig.slmt,
+                mvpd: adobePrimeTimeConfig.mvpd,
+            };
+            return this.player.addCastMetadata(castMetadata);
+        }
         return this.player.addCastMetadata(metadata);
-    }
-    addSubtitle(subtitleTrack) {
+    };
+    MKPlayer.prototype.addSubtitle = function (subtitleTrack) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.addSubtitle(subtitleTrack);
-    }
-    castStop() {
+    };
+    MKPlayer.prototype.castStop = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.castStop();
-    }
-    castVideo() {
+    };
+    MKPlayer.prototype.castVideo = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.castVideo();
-    }
-    destroy() {
+    };
+    MKPlayer.prototype.destroy = function () {
         if (!this.player) {
             return Promise.reject(new Error("Player not yet available!"));
         }
         return this.player.destroy();
-    }
-    disableSubtitle(subtitleID) {
+    };
+    MKPlayer.prototype.disableSubtitle = function (subtitleID) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.disableSubtitle(subtitleID);
-    }
-    enableSubtitle(subtitleID) {
+    };
+    MKPlayer.prototype.enableSubtitle = function (subtitleID) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.enableSubtitle(subtitleID);
-    }
-    getAspectRatio() {
+    };
+    MKPlayer.prototype.getAspectRatio = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getAspectRatio();
-    }
-    getAudio() {
+    };
+    MKPlayer.prototype.getAudio = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getAudio();
-    }
-    getAudioQuality() {
+    };
+    MKPlayer.prototype.getAudioQuality = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getAudioQuality();
-    }
-    getAvailableAudio() {
+    };
+    MKPlayer.prototype.getAvailableAudio = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return [];
         }
         return this.player.getAvailableAudio();
-    }
-    getAvailableAudioQualities() {
+    };
+    MKPlayer.prototype.getAvailableAudioQualities = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return [];
         }
         return this.player.getAvailableAudioQualities();
-    }
-    getAvailableSubtitles() {
+    };
+    MKPlayer.prototype.getAvailableSubtitles = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return [];
         }
         return this.player.getAvailableSubtitles();
-    }
-    getAvailableVideoQualities() {
+    };
+    MKPlayer.prototype.getAvailableVideoQualities = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return [];
         }
         return this.player.getAvailableVideoQualities();
-    }
-    getBufferLevel(type, media) {
+    };
+    MKPlayer.prototype.getBufferLevel = function (type, media) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getBufferLevel(type, media);
-    }
-    getBufferedRanges() {
+    };
+    MKPlayer.prototype.getBufferedRanges = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return [];
         }
         return this.player.getBufferedRanges();
-    }
-    getVersion() {
+    };
+    MKPlayer.prototype.getVersion = function () {
         return constants_1.MKConstants.SDK_VERSION;
-    }
-    getVideoContainer() {
+    };
+    MKPlayer.prototype.getVideoContainer = function () {
         if (!this.player)
             return this.videoContainer;
         return this.player.getVideoContainer();
-    }
-    getCurrentTime(mode) {
+    };
+    MKPlayer.prototype.getCurrentTime = function (mode) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getCurrentTime(mode);
-    }
-    getDownloadedAudioData() {
+    };
+    MKPlayer.prototype.getDownloadedAudioData = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getDownloadedAudioData();
-    }
-    getDownloadedVideoData() {
+    };
+    MKPlayer.prototype.getDownloadedVideoData = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getDownloadedVideoData();
-    }
-    getDroppedVideoFrames() {
+    };
+    MKPlayer.prototype.getDroppedVideoFrames = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getDroppedVideoFrames();
-    }
-    getDuration() {
+    };
+    MKPlayer.prototype.getDuration = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getDuration();
-    }
-    getMaxTimeShift() {
+    };
+    MKPlayer.prototype.getMaxTimeShift = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getMaxTimeShift();
-    }
-    getPlaybackAudioData() {
+    };
+    MKPlayer.prototype.getPlaybackAudioData = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getPlaybackAudioData();
-    }
-    getPlaybackSpeed() {
+    };
+    MKPlayer.prototype.getPlaybackSpeed = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getPlaybackSpeed();
-    }
-    getPlaybackVideoData() {
+    };
+    MKPlayer.prototype.getPlaybackVideoData = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getPlaybackVideoData();
-    }
-    getSeekableRange(mode) {
+    };
+    MKPlayer.prototype.getSeekableRange = function (mode) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getSeekableRange(mode);
-    }
-    getThumbnail(time) {
+    };
+    MKPlayer.prototype.getThumbnail = function (time) {
         var _a;
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
@@ -237,471 +322,594 @@ class MKPlayer extends common_1.MKEventBase {
             return this.thumbnailManager.getThumbnail(time);
         }
         return null;
-    }
-    getTimeShift() {
+    };
+    MKPlayer.prototype.getTimeShift = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getTimeShift();
-    }
-    getTotalStalledTime() {
+    };
+    MKPlayer.prototype.getTotalStalledTime = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getTotalStalledTime();
-    }
-    getVideoElement() {
+    };
+    MKPlayer.prototype.getVideoElement = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return undefined;
         }
         return this.player.getVideoElement();
-    }
-    getVideoQuality() {
+    };
+    MKPlayer.prototype.getVideoQuality = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getVideoQuality();
-    }
-    getViewMode() {
+    };
+    MKPlayer.prototype.getViewMode = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getViewMode();
-    }
-    getVolume() {
+    };
+    MKPlayer.prototype.getVolume = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getVolume();
-    }
-    hasEnded() {
+    };
+    MKPlayer.prototype.hasEnded = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.hasEnded();
-    }
-    isAirplayActive() {
+    };
+    MKPlayer.prototype.isAirplayActive = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isAirplayActive();
-    }
-    isAirplayAvailable() {
+    };
+    MKPlayer.prototype.isAirplayAvailable = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isAirplayAvailable();
-    }
-    isCastAvailable() {
+    };
+    MKPlayer.prototype.isCastAvailable = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isCastAvailable();
-    }
-    isCasting() {
+    };
+    MKPlayer.prototype.isCasting = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isCasting();
-    }
-    isLive() {
+    };
+    MKPlayer.prototype.isLive = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isLive();
-    }
-    isMuted() {
+    };
+    MKPlayer.prototype.isMuted = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isMuted();
-    }
-    isPaused() {
+    };
+    MKPlayer.prototype.isPaused = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isPaused();
-    }
-    isPlaying() {
+    };
+    MKPlayer.prototype.isPlaying = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isPlaying();
-    }
-    isStalled() {
+    };
+    MKPlayer.prototype.isStalled = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.isStalled();
-    }
-    isViewModeAvailable(viewMode) {
+    };
+    MKPlayer.prototype.isViewModeAvailable = function (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);
-                                if (!!signature) {
-                                    this.updateHttpHeaders({
-                                        "X-MK-Signature": signature,
-                                        "AuthorizationToken": (_c = sourceConfig.registered) === null || _c === void 0 ? void 0 : _c.environmentConfig.authToken
-                                    });
-                                }
-                                else {
-                                    common_1.MKLog.warn("Invalid secureUrl signature!");
+    };
+    MKPlayer.prototype.load = function (sourceConfig, disableSeeking) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.emit(enums_1.MKPlayerEvent.TuneStarted, {
+                            type: enums_1.MKPlayerEvent.TuneStarted,
+                            timestamp: MKUtils_1.MKUtils.getCurrentTimestamp()
+                        });
+                        if (!this.sourceLoaded) return [3, 2];
+                        return [4, this.unload()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2, new Promise(function (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(function () { return resolve(); })
+                                    .catch(function (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(function (rollInfo) { return __awaiter(_this, void 0, void 0, function () {
+                                    var controlBlockingRestrictions, fmtsASiDEventData, signature, _a, randomDecimal, randomNumber;
+                                    var _this = this;
+                                    var _b, _c, _d, _e;
+                                    return __generator(this, function (_f) {
+                                        switch (_f.label) {
+                                            case 0:
+                                                this.sendAnalyticsDataEvent(enums_1.MKAnalyticsDataName.Registration, MKAzukiRequest_1.MKAzukiRequest.responseTime.registration);
+                                                this.sendAnalyticsDataEvent(enums_1.MKAnalyticsDataName.Roll, MKAzukiRequest_1.MKAzukiRequest.responseTime.roll);
+                                                this.sendAnalyticsDataEvent(enums_1.MKAnalyticsDataName.DRMType, rollInfo.drmType);
+                                                if (rollInfo.beaconInterval > 0) {
+                                                    this.sendAnalyticsDataEvent(enums_1.MKAnalyticsDataName.BeaconInterval, rollInfo.beaconInterval);
+                                                    (_b = this.azukiRequest) === null || _b === void 0 ? void 0 : _b.setAnalyticsDataCallback(this.sendAnalyticsDataEvent.bind(this));
+                                                }
+                                                this.programManager = new common_1.MKProgramManager(this.azukiRequest);
+                                                controlBlockingRestrictions = this.programManager.validateProgramRestrictions(rollInfo.programInfo);
+                                                if (controlBlockingRestrictions.length > 0) {
+                                                    this.emitProgramRestrictionsEvent(controlBlockingRestrictions);
+                                                }
+                                                if (rollInfo.asidInitToken && rollInfo.asidInitToken.length > 0) {
+                                                    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);
+                                                    (_c = this.programManager) === null || _c === void 0 ? void 0 : _c.updateProgramInfoList(rollInfo.programInfo).then(function () {
+                                                        _this.sendAnalyticsDataEvent(enums_1.MKAnalyticsDataName.ProgramQuery, MKAzukiRequest_1.MKAzukiRequest.responseTime.query);
+                                                    });
+                                                }
+                                                if (rollInfo.failoverSourceUrl) {
+                                                    this.failOverUrl = rollInfo.failoverSourceUrl;
+                                                }
+                                                if ((_d = sourceConfig.cdnOptions) === null || _d === void 0 ? void 0 : _d.cdnTokens) {
+                                                    rollInfo.sourceUrl = MKUtils_1.MKUtils.updateURLQueryParams(rollInfo.sourceUrl, sourceConfig.cdnOptions.cdnTokens);
+                                                    if (rollInfo.failoverSourceUrl) {
+                                                        this.failOverUrl = MKUtils_1.MKUtils.updateURLQueryParams(rollInfo.failoverSourceUrl, sourceConfig.cdnOptions.cdnTokens);
+                                                    }
+                                                }
+                                                if (!this.secureUrlManager) return [3, 4];
+                                                _f.label = 1;
+                                            case 1:
+                                                _f.trys.push([1, 3, , 4]);
+                                                return [4, this.secureUrlManager.getSignature(rollInfo.sourceUrl)];
+                                            case 2:
+                                                signature = _f.sent();
+                                                this.updateHttpHeaders({
+                                                    "X-MK-Signature": signature,
+                                                    "AuthorizationToken": (_e = sourceConfig.registered) === null || _e === void 0 ? void 0 : _e.environmentConfig.authToken
+                                                });
+                                                return [3, 4];
+                                            case 3:
+                                                _a = _f.sent();
+                                                common_1.MKLog.warn("Failed to get signature from secureUrlManager!");
+                                                return [3, 4];
+                                            case 4:
+                                                if (rollInfo.analytics_publish_percent) {
+                                                    randomDecimal = Math.random();
+                                                    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 - ".concat(randomNumber, " is greater than threshold value - ").concat(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 - ".concat(randomNumber, " is lesser than threshold value - ").concat(rollInfo.analytics_publish_percent));
+                                                    }
+                                                }
+                                                this.loadSource(this.updateSourceConfigFromRollInfo(sourceConfig, rollInfo), disableSeeking)
+                                                    .then(function () { return resolve(); })
+                                                    .catch(function (error) { return reject(error); });
+                                                return [2];
+                                        }
+                                    });
+                                }); })
+                                    .catch(function (error) {
+                                    return reject(_this.unloadAndEmitErrorEvent(error, false));
+                                });
                             }
-                            catch (_d) {
-                                common_1.MKLog.warn("Failed to get signature from secureUrlManager!");
+                            else {
+                                return reject(new Error("Source type not supported!"));
                             }
-                        }
-                        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) {
+    };
+    MKPlayer.prototype.reload = function (start, sourceOptions) {
         if (!this.player) {
             return Promise.reject(new Error("Player not yet available!"));
         }
         return this.player.reload(start, sourceOptions);
-    }
-    mute(issuer) {
+    };
+    MKPlayer.prototype.mute = function (issuer) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.mute(issuer);
-    }
-    pause(issuer) {
+    };
+    MKPlayer.prototype.pause = function (issuer) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.pause(issuer);
-    }
-    play(issuer) {
+    };
+    MKPlayer.prototype.play = function (issuer) {
         if (!this.player) {
             return Promise.reject(new Error("Player not yet available!"));
         }
         return this.player.play(issuer);
-    }
-    preload() {
+    };
+    MKPlayer.prototype.preload = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.preload();
-    }
-    removeSubtitle(subtitleID) {
+    };
+    MKPlayer.prototype.removeSubtitle = function (subtitleID) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.removeSubtitle(subtitleID);
-    }
-    seek(time, issuer) {
+    };
+    MKPlayer.prototype.seek = function (time, issuer) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return false;
         }
         return this.player.seek(time, issuer);
-    }
-    seekToLiveEdge(issuer) {
+    };
+    MKPlayer.prototype.seekToLiveEdge = function (issuer) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.seekToLiveEdge(issuer);
-    }
-    setAspectRatio(aspectratio) {
+    };
+    MKPlayer.prototype.setAspectRatio = function (aspectratio) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setAspectRatio(aspectratio);
-    }
-    setAudio(trackID) {
+    };
+    MKPlayer.prototype.setAudio = function (trackID) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setAudio(trackID);
-    }
-    setAudioQuality(audioQualityID) {
+    };
+    MKPlayer.prototype.setAudioQuality = function (audioQualityID) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setAudioQuality(audioQualityID);
-    }
-    updateAuthToken(authToken) {
+    };
+    MKPlayer.prototype.updateAuthToken = function (authToken) {
+        var _this = this;
         var _a;
         if (!this.azukiRequest) {
             common_1.MKLog.error("Available only for registered source and after source is loaded!");
             return;
         }
-        if (!!authToken) {
+        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(function (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(function (_error) {
+            common_1.MKLog.warn("Something went wrong while setting http headers on the player for secureUrl signature and authToken!");
+        });
+    };
+    MKPlayer.prototype.setHttpHeaders = function (headers) {
+        var _this = this;
+        var _a, _b;
+        if (headers === null) {
+            (_a = this.player) === null || _a === void 0 ? void 0 : _a.setHttpHeaders(headers);
+            this.headers = null;
+            return;
+        }
+        var authToken = MKUtils_1.MKUtils.pluckValue(headers, "AuthorizationToken");
+        if (this.azukiRequest && this.secureUrlManager && typeof (authToken) === "string" && !!authToken) {
             this.azukiRequest.updateAuthToken(authToken);
-            (_a = this.secureUrlManager) === null || _a === void 0 ? void 0 : _a.updateAuthToken(authToken).then((signature) => {
+            this.secureUrlManager.updateAuthToken(authToken)
+                .then(function (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);
-                }
-            }).catch((_error) => {
-                common_1.MKLog.warn("Something went wrong while setting http headers on the player for secureUrl signature and authToken!");
+                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(function (_) {
+                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);
             });
         }
-    }
-    setHttpHeaders(headers) {
-        if (!this.player) {
-            common_1.MKLog.error("Player not yet available!");
-            return;
+        else {
+            this.updateHttpHeaders(headers);
+            (_b = this.player) === null || _b === void 0 ? void 0 : _b.setHttpHeaders(this.headers);
+            this.thumbnailManager.setHttpHeaders(this.headers);
         }
-        this.updateHttpHeaders(headers);
-        this.player.setHttpHeaders(headers);
-    }
-    setInhomeStatus(inhomeStatus) {
+    };
+    MKPlayer.prototype.setInhomeStatus = function (inhomeStatus) {
         MKAzukiRequest_1.MKAzukiRequest.inhomeStatus = inhomeStatus;
-    }
-    setLocationDetail(locationDetail) {
+    };
+    MKPlayer.prototype.setLocationDetail = function (locationDetail) {
         if (locationDetail) {
             MKAzukiRequest_1.MKAzukiRequest.locationDetail = locationDetail;
         }
         else {
             delete MKAzukiRequest_1.MKAzukiRequest.locationDetail;
         }
-    }
-    setLogLevel(level) {
+    };
+    MKPlayer.prototype.setLogLevel = function (level) {
         var _a;
         common_1.MKLog.setLogLevel(level);
         (_a = this.player) === null || _a === void 0 ? void 0 : _a.setLogLevel(level);
-    }
-    setPlaybackSpeed(speed) {
+    };
+    MKPlayer.prototype.setPlaybackSpeed = function (speed) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setPlaybackSpeed(speed);
-    }
-    setPosterImage(url, keepPersistent) {
+    };
+    MKPlayer.prototype.setPosterImage = function (url, keepPersistent) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setPosterImage(url, keepPersistent);
-    }
-    setTargetBufferLevel(type, value, media) {
+    };
+    MKPlayer.prototype.setTargetBufferLevel = function (type, value, media) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setTargetBufferLevel(type, value, media);
-    }
-    setVideoElement(videoElement) {
+    };
+    MKPlayer.prototype.setVideoElement = function (videoElement) {
         this.videoElement = videoElement;
-    }
-    setVideoQuality(videoQualityID) {
+    };
+    MKPlayer.prototype.setVideoQuality = function (videoQualityID) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setVideoQuality(videoQualityID);
-    }
-    setViewMode(viewMode, options) {
+    };
+    MKPlayer.prototype.setViewMode = function (viewMode, options) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setViewMode(viewMode, options);
-    }
-    setVolume(volume, issuer) {
+    };
+    MKPlayer.prototype.setVolume = function (volume, issuer) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setVolume(volume, issuer);
-    }
-    showAirplayTargetPicker() {
+    };
+    MKPlayer.prototype.showAirplayTargetPicker = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.showAirplayTargetPicker();
-    }
-    unload() {
+    };
+    MKPlayer.prototype.unload = function () {
         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));
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.player) {
+                            return [2, Promise.reject(new Error("Player not yet available!"))];
+                        }
+                        (_a = this.sessionManager) === null || _a === void 0 ? void 0 : _a.stopSession().catch(function (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) return [3, 2];
+                        this.videoElement.src = "";
+                        return [4, this.videoElement.setMediaKeys(null)];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        this.emit(enums_1.MKPlayerEvent.SourceUnload, {
+                            type: enums_1.MKPlayerEvent.SourceUnload,
+                            timestamp: MKUtils_1.MKUtils.getCurrentTimestamp()
+                        });
+                        return [2, this.player.unload()];
+                }
             });
-            if (this.playerConfig.enableHlsImageMediaPlaylistSupport) {
-                this.thumbnailManager.disable();
-            }
-            if (this.videoElement) {
-                this.videoElement.src = "";
-                yield this.videoElement.setMediaKeys(null);
-            }
-            return this.player.unload();
         });
-    }
-    unmute(issuer) {
+    };
+    MKPlayer.prototype.unmute = function (issuer) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.unmute(issuer);
-    }
-    getCatchupConfig() {
+    };
+    MKPlayer.prototype.getCatchupConfig = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getCatchupConfig();
-    }
-    getFallbackConfig() {
+    };
+    MKPlayer.prototype.getFallbackConfig = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return null;
         }
         return this.player.getFallbackConfig();
-    }
-    getLatency() {
+    };
+    MKPlayer.prototype.getLatency = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getLatency();
-    }
-    getTargetLatency() {
+    };
+    MKPlayer.prototype.getTargetLatency = function () {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return 0;
         }
         return this.player.getTargetLatency();
-    }
-    setCatchupConfig(config) {
+    };
+    MKPlayer.prototype.setCatchupConfig = function (config) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setCatchupConfig(config);
-    }
-    setFallbackConfig(config) {
+    };
+    MKPlayer.prototype.setFallbackConfig = function (config) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setFallbackConfig(config);
-    }
-    setTargetLatency(latency) {
+    };
+    MKPlayer.prototype.setTargetLatency = function (latency) {
         if (!this.player) {
             common_1.MKLog.error("Player not yet available!");
             return;
         }
         this.player.setTargetLatency(latency);
-    }
-    updateHttpHeaders(headers) {
-        if (headers !== null && Object.keys(headers).length > 0) {
-            if (this.headers && Object.keys(this.headers).length > 0) {
-                const existingHeaders = this.headers;
-                this.headers = Object.assign({}, existingHeaders, headers);
-            }
-            else {
-                this.headers = headers;
-            }
+    };
+    MKPlayer.prototype.switchCdn = function () {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var signature, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!this.sourceConfig) return [3, 5];
+                        if (!this.secureUrlManager) return [3, 4];
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 3, , 4]);
+                        return [4, this.secureUrlManager.getSignature(this.failOverUrl)];
+                    case 2:
+                        signature = _e.sent();
+                        this.updateHttpHeaders({
+                            "X-MK-Signature": signature,
+                            "AuthorizationToken": (_a = this.sourceConfig.registered) === null || _a === void 0 ? void 0 : _a.environmentConfig.authToken
+                        });
+                        return [3, 4];
+                    case 3:
+                        _d = _e.sent();
+                        common_1.MKLog.warn("Failed to get signature from secureUrlManager!");
+                        return [3, 4];
+                    case 4:
+                        if ((_b = this.sourceConfig) === null || _b === void 0 ? void 0 : _b.dash) {
+                            this.sourceConfig.dash = this.failOverUrl;
+                        }
+                        else if ((_c = this.sourceConfig) === null || _c === void 0 ? void 0 : _c.hls) {
+                            this.sourceConfig.hls = this.failOverUrl;
+                        }
+                        this.loadSource(this.sourceConfig, false);
+                        this.cdnFailoverAttempted = true;
+                        _e.label = 5;
+                    case 5: return [2];
+                }
+            });
+        });
+    };
+    MKPlayer.prototype.updateHttpHeaders = function (headers) {
+        var _a;
+        if (headers === null) {
+            this.headers = null;
         }
         else {
-            this.headers = null;
+            this.headers = Object.assign({}, (_a = this.headers) !== null && _a !== void 0 ? _a : {}, headers);
         }
-    }
-    updateSourceConfigFromRollInfo(sourceConfig, rollInfo) {
+    };
+    MKPlayer.prototype.updateSourceConfigFromRollInfo = function (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;
@@ -713,279 +921,316 @@ class MKPlayer extends common_1.MKEventBase {
             sourceConfig.dash = rollInfo.sourceUrl;
         }
         return sourceConfig;
-    }
-    initializeBitmovinPlayerEngine() {
+    };
+    MKPlayer.prototype.initializeBitmovinPlayerEngine = function () {
         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) {
-                        }
+    };
+    MKPlayer.prototype.initializePlayer = function (sourceConfig) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var _a, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 8, , 9]);
+                        if (!sourceConfig)
+                            return [2, reject(new Error("Invalid source configuration!"))];
+                        if (!(!!sourceConfig.hls || !!sourceConfig.dash || !!sourceConfig.smooth || !!sourceConfig.progressive)) return [3, 6];
+                        if (!(this.player && !(this.player instanceof MKBitmovinPlayer_1.MKBitmovinPlayer))) return [3, 5];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4, this.player.destroy()];
+                    case 2:
+                        _b.sent();
+                        return [3, 4];
+                    case 3:
+                        _a = _b.sent();
+                        return [3, 4];
+                    case 4:
                         this.player = undefined;
-                    }
-                    this.initializeBitmovinPlayerEngine();
-                    return resolve();
-                }
-                else if (sourceConfig.ull) {
-                    return reject(new Error("ULL source not yet supported!"));
+                        _b.label = 5;
+                    case 5:
+                        this.initializeBitmovinPlayerEngine();
+                        return [2, resolve()];
+                    case 6:
+                        if (sourceConfig.ull) {
+                            return [2, reject(new Error("ULL source not yet supported!"))];
+                        }
+                        _b.label = 7;
+                    case 7: return [3, 9];
+                    case 8:
+                        error_1 = _b.sent();
+                        return [2, reject(error_1)];
+                    case 9: return [2];
                 }
-            }
-            catch (error) {
-                return reject(error);
-            }
-        }));
-    }
-    addListeners() {
+            });
+        }); });
+    };
+    MKPlayer.prototype.addListeners = function () {
+        var _this = this;
         if (this.player) {
-            this.player.on(enums_1.MKPlayerEvent.AdBreakFinished, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AdBreakFinished, event);
+            this.player.on(enums_1.MKPlayerEvent.AdBreakFinished, function (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.AdBreakStarted, function (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.AdFinished, function (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.AdMarker, function (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.AdClickThrough, function (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.AdCompanion, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AdCompanion, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AdQuartile, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AdQuartile, event);
+            this.player.on(enums_1.MKPlayerEvent.AdVerification, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AdVerification, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AdStarted, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AdStarted, event);
+            this.player.on(enums_1.MKPlayerEvent.AdQuartile, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AdQuartile, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AirplayAvailable, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AirplayAvailable, event);
+            this.player.on(enums_1.MKPlayerEvent.AdStarted, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AdStarted, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AirplayChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AirplayChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.AirplayAvailable, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AirplayAvailable, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AspectRatioChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AspectRatioChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.AirplayChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AirplayChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioAdaptation, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioAdaptation, event);
+            this.player.on(enums_1.MKPlayerEvent.AspectRatioChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AspectRatioChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioAdded, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioAdded, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioAdaptation, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioAdaptation, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioAdded, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioAdded, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioDownloadQualityChange, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChange, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioDownloadQualityChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioDownloadQualityChange, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChange, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioPlaybackQualityChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioPlaybackQualityChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioDownloadQualityChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioDownloadQualityChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioQualityAdded, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioQualityAdded, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioPlaybackQualityChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioPlaybackQualityChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioQualityChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioQualityChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioQualityAdded, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioQualityAdded, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioQualityRemoved, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioQualityRemoved, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioQualityChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioQualityChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.AudioRemoved, (event) => {
-                this.emit(enums_1.MKPlayerEvent.AudioRemoved, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioQualityRemoved, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioQualityRemoved, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.CastAvailable, (event) => {
-                this.emit(enums_1.MKPlayerEvent.CastAvailable, event);
+            this.player.on(enums_1.MKPlayerEvent.AudioRemoved, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.AudioRemoved, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.CastStart, (event) => {
-                this.emit(enums_1.MKPlayerEvent.CastStart, event);
+            this.player.on(enums_1.MKPlayerEvent.CastAvailable, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.CastAvailable, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.CastStarted, (event) => {
-                this.emit(enums_1.MKPlayerEvent.CastStarted, event);
+            this.player.on(enums_1.MKPlayerEvent.CastStart, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.CastStart, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.CastStopped, (event) => {
-                this.emit(enums_1.MKPlayerEvent.CastStopped, event);
+            this.player.on(enums_1.MKPlayerEvent.CastStarted, function (event) {
+                var _a;
+                if (_this.sessionManager) {
+                    (_a = _this.sessionManager) === null || _a === void 0 ? void 0 : _a.PauseSession();
+                    _this.addCastMetadata(_this.sessionManager.sessionManager === "azuki" ? 0 : 1);
+                }
+                _this.emit(enums_1.MKPlayerEvent.CastStarted, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.CastWaitingForDevice, (event) => {
-                this.emit(enums_1.MKPlayerEvent.CastWaitingForDevice, event);
+            this.player.on(enums_1.MKPlayerEvent.CastStopped, function (event) {
+                var _a;
+                _this.emit(enums_1.MKPlayerEvent.CastStopped, event);
+                (_a = _this.sessionManager) === null || _a === void 0 ? void 0 : _a.startSession();
             });
-            this.player.on(enums_1.MKPlayerEvent.CueEnter, (event) => {
-                this.emit(enums_1.MKPlayerEvent.CueEnter, event);
+            this.player.on(enums_1.MKPlayerEvent.CastWaitingForDevice, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.CastWaitingForDevice, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.CueEnter, function (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.CueExit, function (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.CueParsed, function (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.CueUpdate, function (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.DVRWindowExceeded, function (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.Destroy, function (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.DownloadFinished, function (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.DrmLicenseAdded, function (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.DurationChanged, function (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.Error, function (event) {
+                var mkError = event;
+                if ((mkError.code == enums_1.MKErrorCode.PLAYER_NETWORK_MANIFEST_DOWNLOAD_TIMEOUT ||
+                    mkError.code == enums_1.MKErrorCode.PLAYER_SOURCE_MANIFEST_INVALID ||
+                    mkError.code == enums_1.MKErrorCode.PLAYER_SOURCE_COULD_NOT_LOAD_MANIFEST ||
+                    mkError.code == enums_1.MKErrorCode.NETWORK_ERROR) && !_this.cdnFailoverAttempted) {
+                    _this.switchCdn();
+                }
+                else {
+                    _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.LatencyModeChanged, function (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.Metadata, function (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.MetadataChanged, function (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.MetadataParsed, function (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.Muted, function (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.Paused, function (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.PeriodSwitch, function (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.PeriodSwitched, function (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.Play, function (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.PlaybackFinished, function (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.PlaybackSpeedChanged, function (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.PlayerResized, function (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.Playing, function (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.Ready, function (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.Seek, function (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.Seeked, function (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.SegmentPlayback, function (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.SegmentRequestFinished, function (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.ShowAirplayTargetPicker, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.ShowAirplayTargetPicker, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.SourceLoaded, (event) => {
-                var _a, _b, _c, _d, _e;
-                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) {
+            this.player.on(enums_1.MKPlayerEvent.SourceLoaded, function (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;
+                        _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;
+                    _this.sessionManager = _this.azukiRequest;
                 }
-                (_c = this.sessionManager) === null || _c === void 0 ? void 0 : _c.startSession().catch((error) => {
+                (_c = _this.sessionManager) === null || _c === void 0 ? void 0 : _c.startSession().catch(function (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);
+                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.SourceUnloaded, function (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.StallEnded, function (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.StallStarted, function (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.SubtitleAdded, function (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.SubtitleDisable, function (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.SubtitleDisabled, function (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.SubtitleEnable, function (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.SubtitleEnabled, function (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.SubtitleRemoved, function (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.TargetLatencyChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.TargetLatencyChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.TimeChanged, (event) => {
+            this.player.on(enums_1.MKPlayerEvent.TimeChanged, function (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);
+                _this.emit(enums_1.MKPlayerEvent.TimeChanged, event);
+                var timeChangedEvent = event;
+                if (_this.programManager && ((_a = _this.sourceConfig) === null || _a === void 0 ? void 0 : _a.assetType) === enums_1.MKAssetType.Live) {
+                    var programInfo = _this.programManager.checkProgramBoundary(timeChangedEvent.time);
                     if (programInfo) {
                         try {
-                            const controlBlockingRestrictions = this.programManager.validateProgramRestrictions(programInfo);
+                            var controlBlockingRestrictions = _this.programManager.validateProgramRestrictions(programInfo);
                             if (controlBlockingRestrictions.length > 0) {
-                                this.emitProgramRestrictionsEvent(controlBlockingRestrictions);
+                                _this.emitProgramRestrictionsEvent(controlBlockingRestrictions);
                             }
                             if (programInfo.timeRange) {
-                                this.emitProgramTimeChangedEvent(programInfo.timeRange);
+                                _this.emitProgramTimeChangedEvent(programInfo.timeRange);
                             }
                         }
                         catch (error) {
                             if (MKUtils_1.MKUtils.isMKError(error)) {
-                                this.unloadAndEmitErrorEvent(error);
+                                _this.unloadAndEmitErrorEvent(error);
                             }
                             else {
                                 common_1.MKLog.error("Unhandled error: ", error);
@@ -994,50 +1239,54 @@ class MKPlayer extends common_1.MKEventBase {
                     }
                 }
             });
-            this.player.on(enums_1.MKPlayerEvent.Unmuted, (event) => {
-                this.emit(enums_1.MKPlayerEvent.Unmuted, event);
+            this.player.on(enums_1.MKPlayerEvent.Unmuted, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.Unmuted, event);
+            });
+            this.player.on(enums_1.MKPlayerEvent.VideoAdaptation, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VideoAdaptation, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VideoAdaptation, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VideoAdaptation, event);
+            this.player.on(enums_1.MKPlayerEvent.VideoDownloadQualityChange, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChange, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VideoDownloadQualityChange, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChange, event);
+            this.player.on(enums_1.MKPlayerEvent.VideoDownloadQualityChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VideoDownloadQualityChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VideoDownloadQualityChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.VideoPlaybackQualityChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VideoPlaybackQualityChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VideoPlaybackQualityChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VideoPlaybackQualityChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.VideoQualityAdded, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VideoQualityAdded, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VideoQualityAdded, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VideoQualityAdded, event);
+            this.player.on(enums_1.MKPlayerEvent.VideoQualityChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VideoQualityChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VideoQualityChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VideoQualityChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.VideoQualityRemoved, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VideoQualityRemoved, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VideoQualityRemoved, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VideoQualityRemoved, event);
+            this.player.on(enums_1.MKPlayerEvent.ViewModeChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.ViewModeChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.ViewModeChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.ViewModeChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.VolumeChanged, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VolumeChanged, event);
             });
-            this.player.on(enums_1.MKPlayerEvent.VolumeChanged, (event) => {
-                this.emit(enums_1.MKPlayerEvent.VolumeChanged, event);
+            this.player.on(enums_1.MKPlayerEvent.VSPPSessionIdAvailable, function (event) {
+                _this.emit(enums_1.MKPlayerEvent.VSPPSessionIdAvailable, event);
             });
         }
-    }
-    emitProgramTimeChangedEvent(timeRange) {
-        const programTimeChangedEventData = {
+    };
+    MKPlayer.prototype.emitProgramTimeChangedEvent = function (timeRange) {
+        var programTimeChangedEventData = {
             timeRange: timeRange,
             type: enums_1.MKPlayerEvent.ProgramTimeChanged,
             timestamp: MKUtils_1.MKUtils.getCurrentTimestamp()
         };
         this.emit(enums_1.MKPlayerEvent.ProgramTimeChanged, programTimeChangedEventData);
-    }
-    unloadAndEmitErrorEvent(error, unloadPlayer = true) {
+    };
+    MKPlayer.prototype.unloadAndEmitErrorEvent = function (error, unloadPlayer) {
+        if (unloadPlayer === void 0) { unloadPlayer = true; }
         if (unloadPlayer)
             this.unload();
-        const errorEvent = {
+        var errorEvent = {
             name: error.name,
             code: error.code,
             message: error.message,
@@ -1046,49 +1295,54 @@ class MKPlayer extends common_1.MKEventBase {
         };
         this.emit(enums_1.MKPlayerEvent.Error, errorEvent);
         return errorEvent;
-    }
-    emitProgramRestrictionsEvent(restrictions) {
+    };
+    MKPlayer.prototype.emitProgramRestrictionsEvent = function (restrictions) {
         if (restrictions.length > 0) {
-            const event = {
+            var event_1 = {
                 type: enums_1.MKPlayerEvent.ProgramRestrictions,
                 timestamp: MKUtils_1.MKUtils.getCurrentTimestamp(),
                 programRestrictions: restrictions,
             };
-            this.emit(enums_1.MKPlayerEvent.ProgramRestrictions, event);
+            this.emit(enums_1.MKPlayerEvent.ProgramRestrictions, event_1);
         }
-    }
-    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);
+    };
+    MKPlayer.prototype.loadSource = function (sourceConfig, disableSeeking) {
+        var _this = this;
+        this.emit(enums_1.MKPlayerEvent.SourceLoad, {
+            type: enums_1.MKPlayerEvent.SourceLoad,
+            timestamp: MKUtils_1.MKUtils.getCurrentTimestamp()
+        });
+        return new Promise(function (resolve, reject) {
+            _this.initializePlayer(sourceConfig)
+                .then(function () {
+                _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); });
+                    _this.player.setHttpHeaders(_this.headers);
+                    _this.player.load(_this.sourceConfig, disableSeeking)
+                        .then(function () { return resolve(); })
+                        .catch(function (error) { return reject(error); });
                 }
                 else {
                     return reject(new Error("Invalid player instance!"));
                 }
             })
-                .catch((error) => {
+                .catch(function (error) {
                 return reject(error);
             });
         });
-    }
-    onSessionConcurrencyNotificationError(error) {
+    };
+    MKPlayer.prototype.onSessionConcurrencyNotificationError = function (error) {
         var _a;
-        const errorCodes = [
+        var 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) => {
+            (_a = this.sessionManager) === null || _a === void 0 ? void 0 : _a.stopSession().catch(function (error) {
                 common_1.MKLog.warn("stopSession failed for sesison concurrency with error: ", JSON.stringify(error));
             });
             this.unloadAndEmitErrorEvent(error, true);
@@ -1096,7 +1350,17 @@ class MKPlayer extends common_1.MKEventBase {
         else {
             common_1.MKLog.warn("Session concurrency notification failed with error: ", JSON.stringify(error));
         }
-    }
-}
+    };
+    MKPlayer.prototype.sendAnalyticsDataEvent = function (name, value) {
+        var event = {
+            dataName: name,
+            dataValue: value,
+            type: enums_1.MKPlayerEvent.AnalyticsDataAvailable,
+            timestamp: MKUtils_1.MKUtils.getCurrentTimestamp()
+        };
+        this.emit(enums_1.MKPlayerEvent.AnalyticsDataAvailable, event);
+    };
+    return MKPlayer;
+}(common_1.MKEventBase));
 exports.MKPlayer = MKPlayer;
 //# sourceMappingURL=MKPlayer.js.map