unified-video-framework 1.4.431 → 1.4.432

package/packages/web/src/WebPlayer.ts

@@ -22,6 +22,8 @@ import {
 } from './chapters/types/ChapterTypes';
 import type { FlashNewsTickerConfig } from './react/types/FlashNewsTickerTypes';
 import YouTubeExtractor from './utils/YouTubeExtractor';
+import { DRMManager, DRMErrorHandler } from '../dist/drm';
+import type { DRMInitResult, DRMError } from '../dist/drm';
 
 // Dynamic imports for streaming libraries
 declare global {
@@ -142,6 +144,10 @@ export class WebPlayer extends BasePlayer {
   // Chapter management
   private chapterManager: ChapterManager | null = null;
 
+  // DRM management
+  private drmManager: DRMManager | null = null;
+  private isDRMProtected: boolean = false;
+
   // Start time tracking
   private hasAppliedStartTime: boolean = false;
   private coreChapterManager: CoreChapterManager | null = null;
@@ -700,6 +706,10 @@ export class WebPlayer extends BasePlayer {
     this.source = source as any;
     this.subtitles = (source.subtitles || []) as any;
 
+    // Check if this is DRM-protected content
+    this.isDRMProtected = !!(source.drm && source.drm.licenseUrl);
+    this.debugLog('DRM config provided:', source.drm);
+
     this.debugLog('Loading video source:', source.url);
     this.debugLog('Fallback sources provided:', source.fallbackSources);
     this.debugLog('Fallback poster provided:', source.fallbackPoster);
@@ -750,6 +760,16 @@ export class WebPlayer extends BasePlayer {
    * Load a video source (main or fallback)
    */
   private async loadVideoSource(url: string, sourceType: string, source: any): Promise<void> {
+    // Initialize DRM BEFORE loading the video if DRM config exists
+    if (this.isDRMProtected && source.drm) {
+      try {
+        await this.initializeDRM(source.drm);
+      } catch (drmError) {
+        this.handleDRMError(drmError);
+        throw drmError; // Prevent video loading
+      }
+    }
+
     switch (sourceType) {
       case 'hls':
         await this.loadHLS(url);
@@ -782,6 +802,75 @@ export class WebPlayer extends BasePlayer {
     }
   }
 
+  /**
+   * Initialize DRM system for protected content
+   */
+  private async initializeDRM(drmConfig: any): Promise<void> {
+    if (!this.video) {
+      throw new Error('Video element not initialized');
+    }
+
+    this.debugLog('Initializing DRM protection...');
+    this.debugLog('DRM Config:', {
+      type: drmConfig.type,
+      licenseUrl: drmConfig.licenseUrl,
+      certificateUrl: drmConfig.certificateUrl
+    });
+
+    try {
+      // Create DRMManager instance
+      this.drmManager = new DRMManager(
+        this.video,
+        drmConfig,
+        this.config.debug
+      );
+
+      // Initialize DRM system
+      const initResult: DRMInitResult = await this.drmManager.initialize();
+
+      if (!initResult.success) {
+        const error = initResult.error!;
+        this.debugError('DRM initialization failed:', error);
+        throw error;
+      }
+
+      this.debugLog('DRM initialized successfully:', {
+        drmType: initResult.drmType,
+        keySystem: initResult.keySystem
+      });
+
+    } catch (error) {
+      this.debugError('DRM initialization error:', error);
+      if (this.drmManager) {
+        await this.drmManager.destroy();
+        this.drmManager = null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Handle DRM-specific errors with user-friendly messages
+   */
+  private handleDRMError(error: any): void {
+    const userMessage = DRMErrorHandler.getUserFriendlyMessage(error);
+    const technicalMessage = DRMErrorHandler.getTechnicalMessage(error);
+
+    this.showNotification(userMessage);
+    this.debugError('DRM Error:', technicalMessage);
+
+    this.handleError({
+      code: error.code || 'DRM_ERROR',
+      message: userMessage,
+      type: 'drm',
+      fatal: true,
+      details: {
+        technical: technicalMessage,
+        original: error
+      }
+    });
+  }
+
   /**
    * Try loading the next fallback source
    */
@@ -1015,6 +1104,18 @@ export class WebPlayer extends BasePlayer {
         this.debugLog(`⏩ HLS startPosition set to: ${this.config.startTime}s (continue watching)`);
       }
 
+      // Apply DRM configuration if available
+      if (this.isDRMProtected && this.drmManager) {
+        try {
+          const drmHlsConfig = this.drmManager.getHLSConfig();
+          Object.assign(hlsConfig, drmHlsConfig);
+          this.debugLog('Applied DRM config to HLS.js');
+        } catch (error) {
+          this.debugError('Failed to get HLS DRM config:', error);
+          throw error;
+        }
+      }
+
       this.hls = new window.Hls(hlsConfig);
 
       this.hls.loadSource(url);
@@ -1106,6 +1207,18 @@ export class WebPlayer extends BasePlayer {
 
     this.dash.initialize(this.video, url, this.config.autoPlay);
 
+    // Apply DRM protection data if available
+    if (this.isDRMProtected && this.drmManager) {
+      try {
+        const protectionData = this.drmManager.getDashProtectionData();
+        this.dash.setProtectionData(protectionData);
+        this.debugLog('Applied DRM protection data to dash.js');
+      } catch (error) {
+        this.debugError('Failed to apply DASH DRM protection:', error);
+        throw error;
+      }
+    }
+
     // Configure DASH settings
     this.dash.updateSettings({
       streaming: {
@@ -11321,6 +11434,18 @@ export class WebPlayer extends BasePlayer {
   }
 
   private async cleanup(): Promise<void> {
+    // Clean up DRM resources first
+    if (this.drmManager) {
+      try {
+        await this.drmManager.destroy();
+        this.debugLog('DRM manager destroyed');
+      } catch (error) {
+        this.debugError('Error destroying DRM manager:', error);
+      }
+      this.drmManager = null;
+    }
+    this.isDRMProtected = false;
+
     if (this.hls) {
       this.hls.destroy();
       this.hls = null;