unified-video-framework 1.4.412 → 1.4.414

package/packages/web/src/drm/WidevineDRMHandler.ts

@@ -1,246 +0,0 @@
-/**
- * Widevine DRM Handler
- * Implements DRM for Chrome, Edge, Firefox using Encrypted Media Extensions (EME)
- */
-
-import { IDRMHandler, WebDRMConfig, DRM_KEY_SYSTEMS, DRMError } from './types/DRMTypes';
-import { BunnyCDNDRMProvider } from './BunnyCDNDRMProvider';
-
-export class WidevineDRMHandler implements IDRMHandler {
-  private mediaKeys: MediaKeys | null = null;
-  private config: WebDRMConfig;
-  private bunnyProvider: BunnyCDNDRMProvider | null = null;
-  private videoElement: HTMLVideoElement | null = null;
-  private pendingLicenseRequests: Map<string, (license: ArrayBuffer) => void> = new Map();
-
-  constructor(config: WebDRMConfig) {
-    this.config = config;
-
-    if (config.provider === 'bunny' && config.bunny) {
-      this.bunnyProvider = new BunnyCDNDRMProvider(config.bunny);
-    }
-  }
-
-  /**
-   * Check if Widevine is supported in current browser
-   */
-  isSupported(): boolean {
-    return !!(
-      typeof navigator.requestMediaKeySystemAccess === 'function' &&
-      typeof window.MediaKeySystemAccess !== 'undefined'
-    );
-  }
-
-  /**
-   * Initialize Widevine DRM system
-   */
-  async initialize(): Promise<void> {
-    if (!this.isSupported()) {
-      throw new DRMError(
-        'Widevine DRM is not supported in this browser',
-        'WIDEVINE_NOT_SUPPORTED'
-      );
-    }
-
-    console.log('[Widevine] Initializing DRM system...');
-
-    try {
-      // Request access to Widevine key system
-      const keySystemAccess = await navigator.requestMediaKeySystemAccess(
-        DRM_KEY_SYSTEMS.WIDEVINE,
-        this.getKeySystemConfiguration()
-      );
-
-      // Create MediaKeys instance
-      this.mediaKeys = await keySystemAccess.createMediaKeys();
-
-      console.log('[Widevine] MediaKeys created successfully');
-    } catch (error) {
-      console.error('[Widevine] Failed to initialize:', error);
-      throw new DRMError(
-        'Failed to initialize Widevine DRM',
-        'WIDEVINE_INIT_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Get key system configuration for Widevine
-   */
-  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
-    return [{
-      initDataTypes: ['cenc', 'webm'],
-      audioCapabilities: [
-        { contentType: 'audio/mp4; codecs="mp4a.40.2"' },
-        { contentType: 'audio/webm; codecs="opus"' }
-      ],
-      videoCapabilities: [
-        { contentType: 'video/mp4; codecs="avc1.42E01E"' },
-        { contentType: 'video/mp4; codecs="avc1.4D401E"' },
-        { contentType: 'video/mp4; codecs="avc1.640028"' },
-        { contentType: 'video/webm; codecs="vp9"' }
-      ],
-      distinctiveIdentifier: 'optional',
-      persistentState: 'optional',
-      sessionTypes: ['temporary']
-    }];
-  }
-
-  /**
-   * Setup DRM for video element
-   */
-  async setupDRM(videoElement: HTMLVideoElement, manifestUrl: string): Promise<void> {
-    if (!this.mediaKeys) {
-      throw new DRMError('MediaKeys not initialized', 'MEDIAKEYS_NOT_INITIALIZED');
-    }
-
-    this.videoElement = videoElement;
-
-    // Attach MediaKeys to video element
-    await videoElement.setMediaKeys(this.mediaKeys);
-    console.log('[Widevine] MediaKeys attached to video element');
-
-    // Listen for encrypted events
-    videoElement.addEventListener('encrypted', this.onEncrypted.bind(this));
-  }
-
-  /**
-   * Handle 'encrypted' event from video element
-   */
-  private async onEncrypted(event: MediaEncryptedEvent): Promise<void> {
-    console.log('[Widevine] Encrypted event received:', event.initDataType);
-
-    try {
-      if (!this.mediaKeys) {
-        throw new DRMError('MediaKeys not available', 'MEDIAKEYS_NOT_AVAILABLE');
-      }
-
-      // Create media key session
-      const session = this.mediaKeys.createSession();
-
-      // Listen for message event (license request)
-      session.addEventListener('message', async (messageEvent: MediaKeyMessageEvent) => {
-        await this.onMessage(session, messageEvent);
-      });
-
-      // Generate license request
-      await session.generateRequest(event.initDataType!, event.initData!);
-      console.log('[Widevine] License request generated');
-
-    } catch (error) {
-      console.error('[Widevine] Failed to handle encrypted event:', error);
-      throw new DRMError(
-        'Failed to process encrypted media',
-        'ENCRYPTED_EVENT_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Handle license request message
-   */
-  private async onMessage(
-    session: MediaKeySession,
-    event: MediaKeyMessageEvent
-  ): Promise<void> {
-    console.log('[Widevine] License request message:', event.messageType);
-
-    try {
-      // Get license from server
-      const license = await this.requestLicense(event.message);
-
-      // Update session with license
-      await session.update(license);
-      console.log('[Widevine] License applied successfully');
-
-    } catch (error) {
-      console.error('[Widevine] Failed to process license:', error);
-      throw new DRMError(
-        'Failed to process DRM license',
-        'LICENSE_REQUEST_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Request license from license server
-   */
-  private async requestLicense(challenge: ArrayBuffer): Promise<ArrayBuffer> {
-    const licenseUrl = this.getLicenseUrl();
-    const headers = await this.getLicenseHeaders();
-
-    console.log('[Widevine] Requesting license from:', licenseUrl);
-
-    try {
-      const response = await fetch(licenseUrl, {
-        method: 'POST',
-        headers,
-        body: challenge
-      });
-
-      if (!response.ok) {
-        throw new Error(`License request failed: ${response.status} ${response.statusText}`);
-      }
-
-      const license = await response.arrayBuffer();
-      console.log('[Widevine] License received:', license.byteLength, 'bytes');
-
-      return license;
-
-    } catch (error) {
-      console.error('[Widevine] License request failed:', error);
-      throw new DRMError(
-        'Failed to retrieve DRM license',
-        'LICENSE_FETCH_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Get license URL based on provider
-   */
-  private getLicenseUrl(): string {
-    if (this.config.provider === 'bunny' && this.bunnyProvider) {
-      return this.bunnyProvider.getWidevineLicenseUrl();
-    } else if (this.config.provider === 'generic' && this.config.generic) {
-      return this.config.generic.licenseUrl;
-    }
-    throw new DRMError('No license URL configured', 'NO_LICENSE_URL');
-  }
-
-  /**
-   * Get headers for license request
-   */
-  private async getLicenseHeaders(): Promise<Record<string, string>> {
-    if (this.config.provider === 'bunny' && this.bunnyProvider) {
-      return await this.bunnyProvider.getLicenseHeaders();
-    } else if (this.config.provider === 'generic' && this.config.generic) {
-      return this.config.generic.headers || { 'Content-Type': 'application/octet-stream' };
-    }
-    return { 'Content-Type': 'application/octet-stream' };
-  }
-
-  /**
-   * Handle license request (called by DRM manager)
-   */
-  async onLicenseRequest(licenseRequest: ArrayBuffer): Promise<ArrayBuffer> {
-    return await this.requestLicense(licenseRequest);
-  }
-
-  /**
-   * Cleanup resources
-   */
-  destroy(): void {
-    if (this.videoElement) {
-      this.videoElement.removeEventListener('encrypted', this.onEncrypted.bind(this));
-      this.videoElement = null;
-    }
-    this.mediaKeys = null;
-    this.bunnyProvider = null;
-    this.pendingLicenseRequests.clear();
-  }
-}