rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.20220317

package/CHANGELOG.md

@@ -1,21 +1,35 @@
 # Changelog
 
-## v3.26.3-dev.2022021400 (2022-02-14)
+## v3.27.0-dev.2022031700 (2022-03-17)
+
+### Features
+
+  - Add a `maxVideoBufferSize` constructor option and `{get,set}MaxVideoBufferSize` methods to limit the size of loaded video data buffered at the same time [#1041, #1054]
+  - DRM: Add a `"periods"` mode to the `keySystems[].singleLicensePer` `loadVideo` option, allowing to obtain decryption license for groups of Periods allowing a compromise between optimization, features and compatibility [#1028, #1061]
 
 ### Bug fixes
 
   - subtitles: Fix rare issue where subtitles could be skipped due to a rounding error [#1064]
   - DASH: fix issue where the wrong segments would be requested on $Number$-based MPD with a SegmentTimeline older than the `timeShiftBufferDepth` [#1052, #1060]
   - directfile: disable all audio tracks before enabling one to work-around Safari issue on MacOS Monterey [#1067]
+  - avoid performing a small seek when changing the audio track [#1080]
+  - api: allow switching to RELOADING state synchronously after LOADED [#1083]
+  - Safari Mobile: Improve decryption support on Safari mobile by relying on the vendored `WebKitMediaKeys` API [#1072]
   - avoid unnecessary warning logs when loading some initialization segments [#1049]
   - TypeScript: Add forgotten TypeScript types in the exposed segment and manifest loader APIs [#1057]
+  - DRM: Avoid decryption issues when a license is persisted in a `singleLicensePer` `"init-data"` mode but loaded in a `"content"` mode [#1031, #1042]
 
 ### Other improvements
 
   - DASH: always consider that the non-last Period is finished when it contains SegmentTimeline elements [#1047]
   - add better buffer cleaning logic on a browser's `QuotaExceededError` to better handle memory limitations [#1065]
+  - DASH: Prioritize selectionPriority attribute over a "main" Role when ordering AdaptationSets [#1082]
+  - directfile/Safari: use the `getStartDate` method in `getWallClockTime` when available to obtain true offseted times when playing HLS contents on Safari [#1055]
   - avoid mistakenly relying on pinkie's Promise implementation when a native one is already available [#1058]
+  - DRM: Improve DRM Session caches performance when `singleLicensePer` is set to `"content"`
+  - TypeScript: Add IBitrateEstimate, IPositionUpdate and IPlayerState types to the exported types [#1084]
   - tests: add performance tests, to better catch and avoid performance regressions [#1053, #1062]
+  - DRM: Refactor DRM logic for better maintainability. DRM-linked logs are now prefixed by `DRM:` instead of `EME:` like previously [#1042]
 
 
 ## v3.26.2 (2022-01-11)

package/FILES.md

@@ -25,7 +25,7 @@ a single directory or subdirectory, in alphabetical order.
   - [src/core/abr/: The adaptive bitrate code](#core-abr)
   - [src/core/api/: The API definition](#core-api)
   - [src/core/stream/: Load the right segments](#core-stream)
-  - [src/core/eme/: Encryption management](#core-eme)
+  - [src/core/decrypt/: Decryption management](#core-decrypt)
   - [src/core/fetchers/: The fetchers](#core-fetchers)
   - [src/core/segment_buffers/: The Media buffers](#core-sb)
   - [src/core/init/: Media streaming logic](#core-init)
@@ -240,10 +240,11 @@ The code there calculate which segments should be downloaded, ask for their
 download and push the segments into the `SegmentBuffers`.
 
 
-<a name="core-eme"></a>
-### src/core/eme/: Encryption management #######################################
+<a name="core-decrypt"></a>
+### src/core/decrypt/: Decryption management ###################################
 
-Defines functions allowing to handle encrypted contents through the EME APIs.
+Defines functions allowing to handle encrypted contents through the EME browser
+APIs.
 
 
 <a name="core-fetchers"></a>

package/VERSION

@@ -1 +1 @@
-3.26.3-dev.2022021400
+3.27.0-dev.2022031700

package/dist/_esm5.processed/compat/browser_detection.d.ts

@@ -19,6 +19,8 @@ declare const isEdgeChromium: boolean;
 declare const isFirefox: boolean;
 declare const isSamsungBrowser: boolean;
 declare const isTizen: boolean;
-declare const isSafari: boolean;
+/** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
+declare const isSafariDesktop: boolean;
+/** `true` on Safari on an iPhone, iPad & iPod platform */
 declare const isSafariMobile: boolean;
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafari, isSafariMobile, isSamsungBrowser, isTizen, };
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, };

package/dist/_esm5.processed/compat/browser_detection.js

@@ -34,10 +34,12 @@ var isSamsungBrowser = !isNode &&
     /SamsungBrowser/.test(navigator.userAgent);
 var isTizen = !isNode &&
     /Tizen/.test(navigator.userAgent);
-var isSafari = !isNode && (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
+/** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
+var isSafariDesktop = !isNode && (Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
     ((_b = (_a = window.safari) === null || _a === void 0 ? void 0 : _a.pushNotification) === null || _b === void 0 ? void 0 : _b.toString()) ===
         "[object SafariRemoteNotification]");
+/** `true` on Safari on an iPhone, iPad & iPod platform */
 var isSafariMobile = !isNode &&
     typeof navigator.platform === "string" &&
     /iPad|iPhone|iPod/.test(navigator.platform);
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafari, isSafariMobile, isSamsungBrowser, isTizen, };
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, };

package/dist/_esm5.processed/compat/eme/close_session.d.ts

@@ -13,12 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 /**
- * Close session and returns and observable that emits when
- * the session is closed.
+ * Close the given `MediaKeySession` and returns a Promise resolving when the
+ * session is closed.
+ * This promise does not reject, even if we're unable to close the
+ * `MediaKeySession`.
+ *
+ * Note that there is a lot of browser issues linked to the impossibility to
+ * either close a MediaKeySession or to know if a MediaKeySession was closed.
+ * Due to this, the returned Promise might take some time before resolving on
+ * some devices.
  * @param {MediaKeySession|Object} session
- * @returns {Observable}
+ * @returns {Promise.<undefined>}
  */
-export default function closeSession$(session: MediaKeySession | ICustomMediaKeySession): Observable<unknown>;
+export default function closeSession(session: MediaKeySession | ICustomMediaKeySession): Promise<void>;

package/dist/_esm5.processed/compat/eme/close_session.js

@@ -13,43 +13,151 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { catchError, map, mergeMap, of as observableOf, race as observableRace, timer as observableTimer, } from "rxjs";
-import castToObservable from "../../utils/cast_to_observable";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 (_) 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 };
+    }
+};
+import log from "../../log";
+import cancellableSleep from "../../utils/cancellable_sleep";
+import PPromise from "../../utils/promise";
+import TaskCanceller, { CancellationError, } from "../../utils/task_canceller";
 /**
- * Close session and returns and observable that emits when
- * the session is closed.
+ * Close the given `MediaKeySession` and returns a Promise resolving when the
+ * session is closed.
+ * This promise does not reject, even if we're unable to close the
+ * `MediaKeySession`.
+ *
+ * Note that there is a lot of browser issues linked to the impossibility to
+ * either close a MediaKeySession or to know if a MediaKeySession was closed.
+ * Due to this, the returned Promise might take some time before resolving on
+ * some devices.
  * @param {MediaKeySession|Object} session
- * @returns {Observable}
+ * @returns {Promise.<undefined>}
  */
-export default function closeSession$(session) {
-    return observableRace(castToObservable(session.close()), 
-    // If the session is not closed after 1000ms, try
-    // to call another method on session to guess if
-    // session is closed or not.
-    observableTimer(1000).pipe(mergeMap(function () {
-        var tryToUpdateSession$ = castToObservable(session.update(new Uint8Array(1)));
-        return tryToUpdateSession$.pipe(
-        // Update has resolved, so we can't know if session is closed
-        map(function () {
-            throw new Error("Compat: Couldn't know if session is " +
-                "closed");
-        }), catchError(function (err) {
-            // The caught error can tell if session is closed
-            // (Chrome may throw this error)
-            if (err instanceof Error &&
-                err.message === "The session is already closed.") {
-                return observableOf(null);
-            }
-            // The `closed` promise may resolve, even if `close()` result has not
-            // (it may happen on Firefox). Wait for it and timeout after 1 second.
-            // TODO There is a subtle TypeScript issue there that made casting to
-            // a type-compatible type mandatory. If a more elegant solution can
-            // be found, it should be preffered.
-            var sessionIsClosed$ = castToObservable(session.closed);
-            return observableRace(sessionIsClosed$, observableTimer(1000).pipe(map(function () {
-                throw new Error("Compat: Couldn't know if session is " +
-                    "closed");
-            })));
-        }));
-    })));
+export default function closeSession(session) {
+    var timeoutCanceller = new TaskCanceller();
+    return PPromise.race([
+        session.close()
+            .then(function () { timeoutCanceller.cancel(); }),
+        // The `closed` promise may resolve, even if `close()` result has not
+        // (seen at some point on Firefox).
+        session.closed
+            .then(function () { timeoutCanceller.cancel(); }),
+        waitTimeoutAndCheck(),
+    ]);
+    /**
+     * If the session is not closed after 1000ms, try to communicate with the
+     * MediaKeySession and check if an error is returned.
+     * This is needed because on some browsers with poor EME implementation,
+     * knowing when a MediaKeySession is closed is actually a hard task.
+     *
+     * The returned Promise will never reject.
+     * @returns {Promise.<undefined>}
+     */
+    function waitTimeoutAndCheck() {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_1, message;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, cancellableSleep(1000, timeoutCanceller.signal)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, tryUpdatingSession()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        if (err_1 instanceof CancellationError) { // cancelled == session closed
+                            return [2 /*return*/];
+                        }
+                        message = err_1 instanceof Error ?
+                            err_1.message :
+                            "Unknown error made it impossible to close the session";
+                        log.error("DRM: ".concat(message));
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     * Try to update `MediaKeySession` and check its error if it failed.
+     * If we still don't know whether it closed yet, wait a second
+     * timeout then quit.
+     *
+     * The returned Promise resolves if the `MediaKeySession` seems closed and
+     * rejects if we couldn't know or it doesn't.
+     * @returns {Promise.<undefined>}
+     */
+    function tryUpdatingSession() {
+        return __awaiter(this, void 0, void 0, function () {
+            var err_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 4]);
+                        return [4 /*yield*/, session.update(new Uint8Array(1))];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        err_2 = _a.sent();
+                        if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+                            return [2 /*return*/];
+                        }
+                        // The caught error can tell if session is closed
+                        // (Chrome may throw this error)
+                        // I know... Checking the error message is not the best practice ever.
+                        if (err_2 instanceof Error &&
+                            err_2.message === "The session is already closed.") {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, cancellableSleep(1000, timeoutCanceller.signal)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+                            return [2 /*return*/];
+                        }
+                        throw new Error("Compat: Couldn't know if session is closed");
+                }
+            });
+        });
+    }
 }

package/dist/_esm5.processed/compat/eme/custom_media_keys/index.d.ts

@@ -13,18 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import CustomMediaKeySystemAccess from "./../custom_key_system_access";
 import { ICustomMediaKeys, ICustomMediaKeySession } from "./types";
 /** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
-declare type ICompatRequestMediaKeySystemAccessFn = (keyType: string, config: MediaKeySystemConfiguration[]) => Observable<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
-declare let requestMediaKeySystemAccess: null | ICompatRequestMediaKeySystemAccessFn;
+declare type ICompatRequestMediaKeySystemAccessFn = (keyType: string, config: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+declare let requestMediaKeySystemAccess: ICompatRequestMediaKeySystemAccessFn | null;
 /**
  * Set the given MediaKeys on the given HTMLMediaElement.
  * Emits null when done then complete.
  * @param {HTMLMediaElement} elt
  * @param {Object} mediaKeys
- * @returns {Observable}
  */
-declare function setMediaKeys(elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null): Observable<unknown>;
+declare let setMediaKeys: ((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown);
 export { requestMediaKeySystemAccess, setMediaKeys, ICustomMediaKeys, ICustomMediaKeySession, };

package/dist/_esm5.processed/compat/eme/custom_media_keys/index.js

@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, of as observableOf, throwError as observableThrow, } from "rxjs";
+import PPromise from "pinkie";
 import { MediaError } from "../../../errors";
 import assert from "../../../utils/assert";
-import castToObservable from "../../../utils/cast_to_observable";
 import { isIE11 } from "../../browser_detection";
 import isNode from "../../is_node";
 import shouldFavourCustomSafariEME from "../../should_favour_custom_safari_EME";
@@ -27,7 +26,13 @@ import getOldKitWebKitMediaKeyCallbacks, { isOldWebkitMediaElement, } from "./ol
 import getWebKitMediaKeysCallbacks from "./webkit_media_keys";
 import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 var requestMediaKeySystemAccess = null;
-var _setMediaKeys = function defaultSetMediaKeys(mediaElement, mediaKeys) {
+/**
+ * Set the given MediaKeys on the given HTMLMediaElement.
+ * Emits null when done then complete.
+ * @param {HTMLMediaElement} elt
+ * @param {Object} mediaKeys
+ */
+var setMediaKeys = function defaultSetMediaKeys(mediaElement, mediaKeys) {
     var elt = mediaElement;
     /* eslint-disable @typescript-eslint/unbound-method */
     if (typeof elt.setMediaKeys === "function") {
@@ -58,8 +63,12 @@ var _setMediaKeys = function defaultSetMediaKeys(mediaElement, mediaKeys) {
  */
 if (isNode ||
     (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())) {
-    requestMediaKeySystemAccess = function (a, b) {
-        return castToObservable(navigator.requestMediaKeySystemAccess(a, b));
+    requestMediaKeySystemAccess = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return navigator.requestMediaKeySystemAccess.apply(navigator, args);
     };
 }
 else {
@@ -70,26 +79,26 @@ else {
         var callbacks = getOldKitWebKitMediaKeyCallbacks();
         isTypeSupported_1 = callbacks.isTypeSupported;
         createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        _setMediaKeys = callbacks.setMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
         // This is for WebKit with prefixed EME api
     }
     else if (WebKitMediaKeysConstructor !== undefined) {
         var callbacks = getWebKitMediaKeysCallbacks();
         isTypeSupported_1 = callbacks.isTypeSupported;
         createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        _setMediaKeys = callbacks.setMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
     }
     else if (isIE11 && MSMediaKeysConstructor !== undefined) {
         var callbacks = getIE11MediaKeysCallbacks();
         isTypeSupported_1 = callbacks.isTypeSupported;
         createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        _setMediaKeys = callbacks.setMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
     }
     else if (MozMediaKeysConstructor !== undefined) {
         var callbacks = getMozMediaKeysCallbacks();
         isTypeSupported_1 = callbacks.isTypeSupported;
         createCustomMediaKeys_1 = callbacks.createCustomMediaKeys;
-        _setMediaKeys = callbacks.setMediaKeys;
+        setMediaKeys = callbacks.setMediaKeys;
     }
     else {
         var MK_1 = window.MediaKeys;
@@ -117,7 +126,7 @@ else {
     }
     requestMediaKeySystemAccess = function (keyType, keySystemConfigurations) {
         if (!isTypeSupported_1(keyType)) {
-            return observableThrow(function () { return new Error("Unsupported key type"); });
+            return PPromise.reject(new Error("Unsupported key type"));
         }
         for (var i = 0; i < keySystemConfigurations.length; i++) {
             var keySystemConfiguration = keySystemConfigurations[i];
@@ -142,20 +151,10 @@ else {
                 }
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 var customMediaKeys = createCustomMediaKeys_1(keyType);
-                return observableOf(new CustomMediaKeySystemAccess(keyType, customMediaKeys, keySystemConfigurationResponse));
+                return PPromise.resolve(new CustomMediaKeySystemAccess(keyType, customMediaKeys, keySystemConfigurationResponse));
             }
         }
-        return observableThrow(function () { return new Error("Unsupported configuration"); });
+        return PPromise.reject(new Error("Unsupported configuration"));
     };
 }
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- * @returns {Observable}
- */
-function setMediaKeys(elt, mediaKeys) {
-    return observableDefer(function () { return castToObservable(_setMediaKeys(elt, mediaKeys)); });
-}
 export { requestMediaKeySystemAccess, setMediaKeys, };

package/dist/_esm5.processed/compat/eme/custom_media_keys/old_webkit_media_keys.js

@@ -28,12 +28,11 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { merge as observableMerge, Subject, takeUntil, } from "rxjs";
 import { base64ToBytes } from "../../../utils/base64";
 import EventEmitter from "../../../utils/event_emitter";
+import noop from "../../../utils/noop";
 import PPromise from "../../../utils/promise";
 import { utf8ToStr } from "../../../utils/string_parsing";
-import * as events from "../../event_listeners";
 /**
  * Returns true if the given media element has old webkit methods
  * corresponding to the IOldWebkitHTMLMediaElement interface.
@@ -44,50 +43,59 @@ export function isOldWebkitMediaElement(element) {
     return typeof element
         .webkitGenerateKeyRequest === "function";
 }
+/**
+ * MediaKeySession implementation for older versions of WebKit relying on APIs
+ * such as `webkitGenerateKeyRequest` `webkitAddKey` to be called on the
+ * HTMLMediaElement.
+ * @class OldWebkitMediaKeySession
+ */
 var OldWebkitMediaKeySession = /** @class */ (function (_super) {
     __extends(OldWebkitMediaKeySession, _super);
     function OldWebkitMediaKeySession(mediaElement, keySystem) {
         var _this = _super.call(this) || this;
-        _this._closeSession$ = new Subject();
         _this._vid = mediaElement;
         _this._key = keySystem;
         _this.sessionId = "";
+        _this._closeSession = noop; // Just here to make TypeScript happy
         _this.closed = new PPromise(function (resolve) {
-            _this._closeSession$.subscribe(resolve);
+            _this._closeSession = resolve;
         });
         _this.keyStatuses = new Map();
         _this.expiration = NaN;
-        observableMerge(events.onKeyMessage$(mediaElement), events.onKeyAdded$(mediaElement), events.onKeyError$(mediaElement))
-            .pipe(takeUntil(_this._closeSession$))
-            .subscribe(function (evt) { return _this.trigger(evt.type, evt); });
-        _this.update = function (license) {
-            return new PPromise(function (resolve, reject) {
-                try {
-                    if (_this._key.indexOf("clearkey") >= 0) {
-                        var licenseTypedArray = license instanceof ArrayBuffer ? new Uint8Array(license) :
-                            license;
-                        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-                        /* eslint-disable @typescript-eslint/no-unsafe-argument */
-                        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-                        var json = JSON.parse(utf8ToStr(licenseTypedArray));
-                        var key = base64ToBytes(json.keys[0].k);
-                        var kid = base64ToBytes(json.keys[0].kid);
-                        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-                        /* eslint-enable @typescript-eslint/no-unsafe-argument */
-                        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-                        resolve(_this._vid.webkitAddKey(_this._key, key, kid, /* sessionId */ ""));
-                    }
-                    else {
-                        resolve(_this._vid.webkitAddKey(_this._key, license, null, /* sessionId */ ""));
-                    }
-                }
-                catch (err) {
-                    reject(err);
-                }
-            });
+        _this._onSessionRelatedEvent = function (evt) {
+            _this.trigger(evt.type, evt);
         };
+        ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+            .forEach(function (evt) { return mediaElement.addEventListener(evt, _this._onSessionRelatedEvent); });
         return _this;
     }
+    OldWebkitMediaKeySession.prototype.update = function (license) {
+        var _this = this;
+        return new PPromise(function (resolve, reject) {
+            try {
+                if (_this._key.indexOf("clearkey") >= 0) {
+                    var licenseTypedArray = license instanceof ArrayBuffer ? new Uint8Array(license) :
+                        license;
+                    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+                    /* eslint-disable @typescript-eslint/no-unsafe-argument */
+                    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+                    var json = JSON.parse(utf8ToStr(licenseTypedArray));
+                    var key = base64ToBytes(json.keys[0].k);
+                    var kid = base64ToBytes(json.keys[0].kid);
+                    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+                    /* eslint-enable @typescript-eslint/no-unsafe-argument */
+                    /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+                    resolve(_this._vid.webkitAddKey(_this._key, key, kid, /* sessionId */ ""));
+                }
+                else {
+                    resolve(_this._vid.webkitAddKey(_this._key, license, null, /* sessionId */ ""));
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
     OldWebkitMediaKeySession.prototype.generateRequest = function (_initDataType, initData) {
         var _this = this;
         return new PPromise(function (resolve) {
@@ -98,17 +106,28 @@ var OldWebkitMediaKeySession = /** @class */ (function (_super) {
     OldWebkitMediaKeySession.prototype.close = function () {
         var _this = this;
         return new PPromise(function (resolve) {
-            _this._closeSession$.next();
-            _this._closeSession$.complete();
+            _this._unbindSession();
+            _this._closeSession();
             resolve();
         });
     };
+    /**
+     * Load a Persistent MediaKeySession.
+     * Do nothing here because this implementation doesn't handle them.
+     * @returns {Promise.<boolean>}
+     */
     OldWebkitMediaKeySession.prototype.load = function () {
+        // Not implemented. Always return false as in "no session with that id".
         return PPromise.resolve(false);
     };
     OldWebkitMediaKeySession.prototype.remove = function () {
         return PPromise.resolve();
     };
+    OldWebkitMediaKeySession.prototype._unbindSession = function () {
+        var _this = this;
+        ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+            .forEach(function (evt) { return _this._vid.removeEventListener(evt, _this._onSessionRelatedEvent); });
+    };
     return OldWebkitMediaKeySession;
 }(EventEmitter));
 var OldWebKitCustomMediaKeys = /** @class */ (function () {