@volcengine/veplayer-plugin 2.8.0-rc.1 → 2.8.0

package/umd/veplayer.plugin.drm.development.js

@@ -1291,12 +1291,25 @@
     KeySystem2["playready"] = "com.microsoft.playready";
     return KeySystem2;
   })(KeySystem || {});
-  function selectKeySystem() {
+  var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+    ErrorCode2[ErrorCode2["UNSUPPORTED"] = 7101] = "UNSUPPORTED";
+    ErrorCode2[ErrorCode2["RECORD"] = 7102] = "RECORD";
+    ErrorCode2[ErrorCode2["NOMEDIAKEY"] = 7103] = "NOMEDIAKEY";
+    ErrorCode2[ErrorCode2["NOKEYSESSION"] = 7104] = "NOKEYSESSION";
+    ErrorCode2[ErrorCode2["GENERATEREQUESTFAIL"] = 7105] = "GENERATEREQUESTFAIL";
+    ErrorCode2[ErrorCode2["LACKSERVERCERTIFICATEPATH"] = 7106] = "LACKSERVERCERTIFICATEPATH";
+    ErrorCode2[ErrorCode2["LACKSERVERPROCESSSPCPATH"] = 7107] = "LACKSERVERPROCESSSPCPATH";
+    ErrorCode2[ErrorCode2["LICENSEFAIL"] = 7108] = "LICENSEFAIL";
+    ErrorCode2[ErrorCode2["KEYERROR"] = 7109] = "KEYERROR";
+    ErrorCode2[ErrorCode2["CERTFAIL"] = 7110] = "CERTFAIL";
+    return ErrorCode2;
+  })(ErrorCode || {});
+  function selectKeySystem(contentType) {
     const options = [
       {
         initDataTypes: ["keyids", "webm"],
         audioCapabilities: [{ contentType: 'audio/mp4; codecs="mp4a.40.2"' }],
-        videoCapabilities: [
+        videoCapabilities: contentType ? [{ contentType }] : [
           { contentType: 'video/mp4; codecs="avc1.42c01e"' },
           { contentType: 'video/mp4; codecs="hev1.1.6.L120.90"' },
           { contentType: 'video/webm; codecs="vp8"' }
@@ -1307,7 +1320,8 @@
       navigator.requestMediaKeySystemAccess(KeySystem.fairplay, options).then((access) => {
         resolve({
           access,
-          system: KeySystem.fairplay
+          system: KeySystem.fairplay,
+          systemName: "fairplay"
         });
       }).catch(() => {
         if (globalThis.WebKitMediaKeys && globalThis.WebKitMediaKeys.isTypeSupported(
@@ -1316,22 +1330,38 @@
         )) {
           resolve({
             access: null,
-            system: KeySystem.fairplay
+            system: KeySystem.fairplay,
+            systemName: "fairplay"
           });
           return;
         }
         navigator.requestMediaKeySystemAccess(KeySystem.widevine, options).then((access) => {
           resolve({
             access,
-            system: KeySystem.widevine
+            system: KeySystem.widevine,
+            systemName: "widevine"
           });
         }).catch(() => {
           navigator.requestMediaKeySystemAccess(KeySystem.playready, options).then((access) => {
             resolve({
               access,
-              system: KeySystem.playready
+              system: KeySystem.playready,
+              systemName: "playready"
             });
-          }).catch(reject);
+          }).catch((e) => {
+            if (globalThis.MSMediaKeys && globalThis.MSMediaKeys.isTypeSupported(
+              KeySystem.playready,
+              "video/mp4"
+            )) {
+              resolve({
+                access: null,
+                system: KeySystem.playready,
+                systemName: "playready"
+              });
+            } else {
+              reject(e);
+            }
+          });
         });
       });
     });
@@ -1348,7 +1378,7 @@
     }
     return array;
   }
-  class Mobile extends BasePlugin {
+  class Drm extends BasePlugin {
     constructor(options) {
       super(options);
       this.unsupported = false;
@@ -1363,17 +1393,15 @@
         event.target;
         let initData = event.initData;
         const initDataType = event.initDataType;
-        const contentId = this.extractContentId(initData);
-        if (this.keySystem === KeySystem.fairplay && !this.certificate) {
-          return this.suspend = () => {
-            this.afterInitDate(initData, contentId, initDataType);
-          };
+        let contentId;
+        if (this.keySystem === KeySystem.fairplay) {
+          contentId = this.extractContentId(initData);
         }
         this.afterInitDate(initData, contentId, initDataType);
       };
       this.licenseRequestReady = (event) => {
         if (!this.serverProcessSPCPath) {
-          this.emitError("lack serverProcessSPCPath");
+          this.emitError(ErrorCode.LACKSERVERPROCESSSPCPATH, "lack serverProcessSPCPath");
           return;
         }
         const message = event.message;
@@ -1383,10 +1411,12 @@
         request.addEventListener("error", this.licenseRequestFailed(event), false);
         var params = new Uint8Array(message);
         request.open("POST", this.serverProcessSPCPath, true);
-        if (this.keySystem === KeySystem.playready) {
-          request.setRequestHeader("Content-type", "text/xml");
-        } else {
-          request.setRequestHeader("Content-type", "application/octet-stream");
+        if (!this.config.ignoreLicenseHeader) {
+          if (this.keySystem === KeySystem.playready) {
+            request.setRequestHeader("Content-type", "text/xml; charset=utf-8");
+          } else {
+            request.setRequestHeader("Content-type", "application/octet-stream");
+          }
         }
         request.send(params);
       };
@@ -1394,16 +1424,13 @@
         const request = event.target;
         const arrayBuffer = request.response;
         let license;
-        if (this.keySystem === KeySystem.playready) {
-          license = this.parseServerResponse(arrayBuffer);
-        } else {
-          license = new Uint8Array(arrayBuffer);
-        }
+        license = new Uint8Array(arrayBuffer);
         if (license) {
           this.keySession.update(license);
         } else {
           this.emitError(
-            `The license response no array buffer, licence: ${license}`
+            ErrorCode.LICENSEFAIL,
+            `The license response no array buffer, license: ${license}`
           );
         }
       };
@@ -1414,16 +1441,17 @@
         } else {
           const request = event.target;
           this.emitError(
+            ErrorCode.LICENSEFAIL,
             `The license request fail, status: ${request.status}, statusText: ${request.statusText}`
           );
         }
       };
       this.onKeyError = () => {
-        this.emitError("A decryption key error was encountered");
+        this.emitError(ErrorCode.KEYERROR, "A decryption key error was encountered");
       };
       this.loadCertificate = () => {
         if (!this.serverCertificatePath) {
-          this.emitError("lack serverCertificatePath");
+          this.emitError(ErrorCode.LACKSERVERCERTIFICATEPATH, "lack serverCertificatePath");
           return;
         }
         const request = new XMLHttpRequest();
@@ -1433,17 +1461,18 @@
         request.open("GET", this.serverCertificatePath, true);
         request.send();
       };
-      this.emitError = (message) => {
+      this.emitError = (errorCode, message) => {
         this.emit("error", {
-          errorCode: 7100,
+          errorCode,
           message,
-          drm_sdk_version: "0.0.0-alpha.5"
+          // @ts-ignore: Cannot find name '"0.0.0-alpha.13"'
+          drm_sdk_version: "0.0.0-alpha.13"
         });
       };
       this.onCertificateLoaded = (event) => {
         const request = event.target;
         this.certificate = new Uint8Array(request.response);
-        this.suspend && this.suspend();
+        this.loadSource();
       };
       this.onCertificateError = (event) => {
         if (this.certRetryTime > 0) {
@@ -1452,6 +1481,7 @@
         } else {
           const request = event.target;
           this.emitError(
+            ErrorCode.CERTFAIL,
             `get cert fail, status: ${request.status}, statusText: ${request.statusText}`
           );
         }
@@ -1461,12 +1491,13 @@
       };
       this.reset();
       const config = options.config || {};
-      this.serverCertificatePath = config.serverCertificatePath;
-      this.serverProcessSPCPath = config.serverProcessSPCPath;
+      this.config = config;
+      this.contentType = this.config.contentType;
       if (typeof config.unRecord === "boolean") {
         this.unRecord = config.unRecord;
       }
       this.checkUnrecord();
+      this.player.handleSource = false;
     }
     static get pluginName() {
       return "drm";
@@ -1477,8 +1508,6 @@
       this._serverCertificatePath = x;
       if (this.keySystem === KeySystem.fairplay) {
         this.certificate = void 0;
-        this.suspend = () => {
-        };
         this.loadCertificate();
       }
     }
@@ -1488,9 +1517,11 @@
     afterCreate() {
       this.media = this.player.video;
       this.media.addEventListener("webkitneedkey", this.onNeedKey, false);
+      this.media.addEventListener("msneedkey", this.onNeedKey, false);
       this.media.addEventListener("needkey", this.onNeedKey, false);
       this.media.addEventListener("encrypted", this.onNeedKey);
       this.player.on("urlchange", this.restart);
+      this.player.on("reset", this.restart);
     }
     async checkUnrecord() {
       if (this.unRecord) {
@@ -1507,60 +1538,101 @@
           });
           this.unsupported = !powerEfficient;
         } catch (error) {
-          this.emitError(`check powerEfficient failed, ${error.message}`);
+          this.emitError(ErrorCode.RECORD, `check powerEfficient failed, ${error.message}`);
           this.unsupported = true;
         }
       }
       if (this.unsupported)
         return;
-      selectKeySystem().then(({ access, system }) => {
+      selectKeySystem(this.contentType).then(({ access, system, systemName }) => {
         this.keySystem = system;
+        this.systemName = systemName;
+        this.setRequestUrl(systemName);
         if (system === KeySystem.fairplay) {
           this.loadCertificate();
+        } else {
+          this.loadSource();
         }
         if (access) {
           this.keySystemAccess = access;
         }
       }).catch((error) => {
-        this.emitError(error.message);
+        this.emitError(ErrorCode.UNSUPPORTED, error.message);
         this.unsupported = true;
       });
     }
+    loadSource() {
+      this.player.retry();
+    }
+    setRequestUrl(systemName) {
+      const systemConfig = this.config[systemName] || this.config;
+      this.serverCertificatePath = systemConfig.serverCertificatePath;
+      this.serverProcessSPCPath = systemConfig.serverProcessSPCPath;
+    }
+    async updateConfig(config) {
+      Object.assign(this.config, config);
+      if (this.config.unRecord && this.contentType !== this.config.contentType) {
+        this.contentType = this.config.contentType;
+        await this.checkUnrecord();
+      }
+      this.setRequestUrl(this.systemName);
+    }
     afterInitDate(initData, contentId, initDataType) {
       if (!this.keySystemAccess) {
-        const mediaKeys = new globalThis.WebKitMediaKeys(this.keySystem);
-        this.media.webkitSetMediaKeys(mediaKeys);
-        if (!this.media.webkitKeys) {
-          this.emitError("Could not create MediaKeys");
-          return;
-        }
-        const keySession = mediaKeys.createSession(
-          "video/mp4",
-          this.concatInitDataIdAndCertificate(initData, contentId)
-        );
-        this.keySession = keySession;
-        if (!keySession) {
-          this.emitError("Could not create key session");
-          return;
+        if (this.keySystem === KeySystem.fairplay) {
+          const mediaKeys = new globalThis.WebKitMediaKeys(this.keySystem);
+          this.media.webkitSetMediaKeys(mediaKeys);
+          if (!this.media.webkitKeys) {
+            this.emitError(ErrorCode.NOMEDIAKEY, "Could not create MediaKeys");
+            return;
+          }
+          const keySession = mediaKeys.createSession(
+            "video/mp4",
+            this.concatInitDataIdAndCertificate(initData, contentId)
+          );
+          this.keySession = keySession;
+          if (!keySession) {
+            this.emitError(ErrorCode.NOKEYSESSION, "Could not create key session");
+            return;
+          }
+          keySession.addEventListener(
+            "webkitkeymessage",
+            this.licenseRequestReady
+          );
+          keySession.addEventListener("webkitkeyerror", this.onKeyError);
+        } else if (this.keySystem === KeySystem.playready) {
+          const mediaKeys = new globalThis.MSMediaKeys(this.keySystem);
+          this.media.msSetMediaKeys(mediaKeys);
+          const keySession = mediaKeys.createSession(
+            "video/mp4",
+            new Uint8Array(initData),
+            null
+          );
+          this.keySession = keySession;
+          if (!keySession) {
+            this.emitError(ErrorCode.NOKEYSESSION, "Could not create key session");
+            return;
+          }
+          keySession.addEventListener("mskeymessage", this.licenseRequestReady);
+          keySession.addEventListener("mskeyerror", this.onKeyError);
         }
-        keySession.addEventListener("webkitkeymessage", this.licenseRequestReady);
-        keySession.addEventListener("webkitkeyerror", this.onKeyError);
       } else {
         this.keySystemAccess.createMediaKeys().then((mediaKeys) => {
           this.media.setMediaKeys(mediaKeys);
           if (this.media.mediaKeys) {
-            this.emitError("Could not create MediaKeys");
+            this.emitError(ErrorCode.NOMEDIAKEY, "Could not create MediaKeys");
             return;
           }
           const keySession = mediaKeys.createSession();
           this.keySession = keySession;
           if (!keySession) {
-            this.emitError("Could not create key session");
+            this.emitError(ErrorCode.NOKEYSESSION, "Could not create key session");
             return;
           }
           keySession.addEventListener("message", this.licenseRequestReady);
-          keySession.generateRequest(initDataType, initData).catch((error) => {
+          keySession.generateRequest(initDataType || this.config.initDataType, initData).catch((error) => {
             this.emitError(
+              ErrorCode.GENERATEREQUESTFAIL,
               `generateRequest failed, code: ${error.errorCode}, message: ${error.message}`
             );
           });
@@ -1634,18 +1706,30 @@
       this.suspend = void 0;
       this.keySession = void 0;
       this.needKeyed = false;
+      if (this.media) {
+        try {
+          this.media.src = "";
+          if (this.keySystem === KeySystem.fairplay) {
+            this.media.webkitSetMediaKeys(null);
+          } else if (this.keySystem === KeySystem.playready) {
+            this.media.msSetMediaKeys(null);
+          } else {
+            this.media.setMediaKeys(null);
+          }
+        } catch (error) {
+        }
+      }
     }
     destroy() {
       this.player.off("urlchange", this.restart);
-    }
-  }
-  class DrmPlugin extends Mobile {
-    updateDrmConfig(data) {
-      data.serverProcessSPCPath && (this.serverProcessSPCPath = data.serverProcessSPCPath);
-      data.serverCertificatePath && (this.serverCertificatePath = data.serverCertificatePath);
+      this.player.off("reset", this.restart);
+      this.media.removeEventListener("webkitneedkey", this.onNeedKey, false);
+      this.media.removeEventListener("msneedkey", this.onNeedKey, false);
+      this.media.removeEventListener("needkey", this.onNeedKey, false);
+      this.media.removeEventListener("encrypted", this.onNeedKey);
     }
   }
   const DynamicModule = window["VePlayer"].DynamicModule;
-  VePlayer.registerPlugin(DynamicModule.PluginDrm, { DrmPlugin });
-  exports2.DrmPlugin = DrmPlugin;
+  VePlayer.registerPlugin(DynamicModule.PluginDrm, { DrmPlugin: Drm });
+  exports2.DrmPlugin = Drm;
 });