unified-video-framework 1.4.412 → 1.4.414

package/packages/web/src/drm/utils/LicenseRequestHandler.ts

@@ -0,0 +1,180 @@
+/**
+ * License Request Handler
+ * Centralized HTTP request handling for license servers with retry logic
+ */
+
+import { ExtendedDRMConfig, LicenseRequest, LicenseResponse, DRMErrorCode } from '../types/DRMTypes';
+
+export class LicenseRequestHandler {
+  private config: ExtendedDRMConfig;
+  private debug: boolean;
+
+  constructor(config: ExtendedDRMConfig, debug: boolean = false) {
+    this.config = config;
+    this.debug = debug;
+  }
+
+  /**
+   * Request license from server with retry logic
+   */
+  async requestLicense(request: LicenseRequest): Promise<LicenseResponse> {
+    const maxRetries = this.config.retryConfig?.maxRetries || 3;
+    const retryDelay = this.config.retryConfig?.retryDelay || 1000;
+
+    let lastError: any;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        if (attempt > 0) {
+          this.log(`Retry attempt ${attempt}/${maxRetries}`);
+          await this.delay(retryDelay * attempt); // Exponential backoff
+        }
+
+        const response = await this.makeRequest(request);
+        return response;
+      } catch (error: any) {
+        lastError = error;
+        this.log(`License request failed (attempt ${attempt + 1}/${maxRetries + 1}):`, error);
+
+        // Don't retry on certain errors
+        if (this.isFatalError(error)) {
+          throw error;
+        }
+      }
+    }
+
+    // All retries exhausted
+    throw this.createError(
+      DRMErrorCode.LICENSE_REQUEST_FAILED,
+      `Failed to request license after ${maxRetries + 1} attempts`,
+      lastError
+    );
+  }
+
+  /**
+   * Make HTTP request to license server
+   */
+  private async makeRequest(request: LicenseRequest): Promise<LicenseResponse> {
+    this.log('Requesting license from:', request.url);
+
+    try {
+      const response = await fetch(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+      });
+
+      if (!response.ok) {
+        throw this.createError(
+          DRMErrorCode.LICENSE_REQUEST_FAILED,
+          `License server returned ${response.status}: ${response.statusText}`,
+          { status: response.status, statusText: response.statusText }
+        );
+      }
+
+      // Parse response based on type
+      let license: ArrayBuffer;
+
+      if (request.responseType === 'arraybuffer') {
+        license = await response.arrayBuffer();
+      } else if (request.responseType === 'text') {
+        const text = await response.text();
+        license = this.textToArrayBuffer(text);
+      } else if (request.responseType === 'json') {
+        const json = await response.json();
+        // Assume license is in a 'license' field or is base64-encoded
+        if (json.license) {
+          license = this.base64ToArrayBuffer(json.license);
+        } else {
+          throw this.createError(
+            DRMErrorCode.LICENSE_INVALID,
+            'License response does not contain license field',
+            json
+          );
+        }
+      } else {
+        license = await response.arrayBuffer();
+      }
+
+      this.log('License received, size:', license.byteLength, 'bytes');
+
+      return {
+        license,
+        metadata: response.headers,
+      };
+    } catch (error: any) {
+      if (error.code && error.code.startsWith('DRM_')) {
+        throw error;
+      }
+
+      throw this.createError(
+        DRMErrorCode.NETWORK_ERROR,
+        `Network error requesting license: ${error.message}`,
+        error
+      );
+    }
+  }
+
+  /**
+   * Check if error is fatal (should not retry)
+   */
+  private isFatalError(error: any): boolean {
+    // Don't retry authentication errors (401, 403)
+    if (error.details?.status === 401 || error.details?.status === 403) {
+      return true;
+    }
+
+    // Don't retry invalid license errors
+    if (error.code === DRMErrorCode.LICENSE_INVALID) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Convert text to ArrayBuffer
+   */
+  private textToArrayBuffer(text: string): ArrayBuffer {
+    const encoder = new TextEncoder();
+    return encoder.encode(text).buffer;
+  }
+
+  /**
+   * Convert base64 string to ArrayBuffer
+   */
+  private base64ToArrayBuffer(base64: string): ArrayBuffer {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+
+  /**
+   * Delay helper for retry logic
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Create standardized DRM error
+   */
+  private createError(code: DRMErrorCode, message: string, details?: any): any {
+    const error = new Error(message);
+    (error as any).code = code;
+    (error as any).details = details;
+    return error;
+  }
+
+  /**
+   * Debug logging
+   */
+  private log(...args: any[]): void {
+    if (this.debug) {
+      console.log('[LicenseRequestHandler]', ...args);
+    }
+  }
+}

package/packages/web/src/react/WebPlayerView.tsx

@@ -1,7 +1,7 @@
 // @ts-nocheck
 import React, { useEffect, useRef, useState, useCallback } from 'react';
 import type { CSSProperties } from 'react';
-import type { VideoSource, SubtitleTrack, VideoMetadata, PlayerConfig, DRMTokenProvider, DRMToken, BunnyCDNDRMConfig } from '../../core/dist';
+import type { VideoSource, SubtitleTrack, VideoMetadata, PlayerConfig } from '../../core/dist';
 import { WebPlayer } from '../WebPlayer';
 import { GoogleAdsManager } from '../ads/GoogleAdsManager';
 // EPG imports - conditionally loaded
@@ -224,26 +224,6 @@ export type WebPlayerViewProps = {
   // Source config
   url: string;
   type?: 'mp4' | 'hls' | 'dash' | 'webm' | 'auto';
-
-  // DRM configuration (optional)
-  drm?: {
-    bunny?: {
-      libraryId: string;
-      videoId: string;
-      pullZoneUrl: string;
-      tokenProvider: DRMTokenProvider;
-      certificateUrl?: string;
-      licenseUrl?: string;
-      enableReferrerProtection?: boolean;
-    };
-    generic?: {
-      type: 'widevine' | 'fairplay';
-      licenseUrl: string;
-      certificateUrl?: string;
-      headers?: Record<string, string>;
-    };
-  };
-
   subtitles?: SubtitleTrack[];
   metadata?: VideoMetadata;
 
@@ -1040,13 +1020,6 @@ export const WebPlayerView: React.FC<WebPlayerViewProps> = (props) => {
           fallbackRetryDelay: props.fallbackRetryDelay,
           fallbackRetryAttempts: props.fallbackRetryAttempts,
           onAllSourcesFailed: props.onAllSourcesFailed,
-
-          // Pass DRM config if provided
-          drm: props.drm ? {
-            type: props.drm.bunny ? 'widevine' : (props.drm.generic?.type || 'widevine'),
-            licenseUrl: props.drm.bunny ? '' : (props.drm.generic?.licenseUrl || ''),
-            bunny: props.drm.bunny
-          } as any : undefined
         };
 
         await player.load(source);

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

@@ -1,104 +0,0 @@
-/**
- * Bunny CDN DRM Provider
- * Handles Bunny CDN specific URL construction and token injection
- */
-
-import { BunnyCDNDRMConfig, DRMToken, DRMError } from './types/DRMTypes';
-
-export class BunnyCDNDRMProvider {
-  constructor(private config: BunnyCDNDRMConfig) {}
-
-  /**
-   * Get FairPlay certificate URL for Bunny CDN
-   */
-  getFairPlayCertificateUrl(): string {
-    if (this.config.certificateUrl) {
-      return this.config.certificateUrl;
-    }
-    return `https://video.bunnycdn.com/FairPlay/${this.config.libraryId}/certificate`;
-  }
-
-  /**
-   * Get FairPlay license URL for Bunny CDN
-   */
-  getFairPlayLicenseUrl(): string {
-    if (this.config.licenseUrl) {
-      return this.config.licenseUrl;
-    }
-    return `https://video.bunnycdn.com/FairPlay/${this.config.libraryId}/license/?videoId=${this.config.videoId}`;
-  }
-
-  /**
-   * Get Widevine license URL for Bunny CDN
-   */
-  getWidevineLicenseUrl(): string {
-    if (this.config.licenseUrl) {
-      return this.config.licenseUrl;
-    }
-    // Bunny CDN Widevine license endpoint
-    return `https://video.bunnycdn.com/Widevine/${this.config.libraryId}/license/?videoId=${this.config.videoId}`;
-  }
-
-  /**
-   * Get HLS manifest URL with token
-   */
-  async getManifestUrl(): Promise<string> {
-    const baseUrl = `https://${this.config.pullZoneUrl}.b-cdn.net/${this.config.videoId}/playlist.m3u8`;
-    const token = await this.config.tokenProvider.getManifestToken();
-
-    if (!token) {
-      throw new DRMError('No manifest token available', 'MANIFEST_TOKEN_ERROR');
-    }
-
-    return this.injectToken(baseUrl, token);
-  }
-
-  /**
-   * Inject token into URL as query parameters
-   */
-  injectToken(url: string, token: DRMToken): string {
-    const urlObj = new URL(url);
-    urlObj.searchParams.set('token', token.token);
-    urlObj.searchParams.set('expires', token.expires.toString());
-    if (token.tokenVer) {
-      urlObj.searchParams.set('token_ver', token.tokenVer);
-    }
-    return urlObj.toString();
-  }
-
-  /**
-   * Get headers for license requests including token
-   */
-  async getLicenseHeaders(): Promise<Record<string, string>> {
-    const token = await this.config.tokenProvider.getLicenseToken();
-
-    if (!token) {
-      throw new DRMError('No license token available', 'LICENSE_TOKEN_ERROR');
-    }
-
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/octet-stream',
-      'X-Bunny-Token': token.token,
-      'X-Bunny-Expires': token.expires.toString(),
-    };
-
-    if (token.tokenVer) {
-      headers['X-Bunny-Token-Version'] = token.tokenVer;
-    }
-
-    if (this.config.enableReferrerProtection) {
-      headers['Referer'] = window.location.origin;
-    }
-
-    return headers;
-  }
-
-  /**
-   * Check if token needs renewal (within 5 minutes of expiry)
-   */
-  shouldRenewToken(token: DRMToken): boolean {
-    const nowSeconds = Math.floor(Date.now() / 1000);
-    const bufferSeconds = 300; // 5 minutes
-    return token.expires - nowSeconds < bufferSeconds;
-  }
-}

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

@@ -1,322 +0,0 @@
-/**
- * FairPlay DRM Handler
- * Implements DRM for Safari using FairPlay Streaming
- */
-
-import { IDRMHandler, WebDRMConfig, DRMError } from './types/DRMTypes';
-import { BunnyCDNDRMProvider } from './BunnyCDNDRMProvider';
-
-export class FairPlayDRMHandler implements IDRMHandler {
-  private config: WebDRMConfig;
-  private bunnyProvider: BunnyCDNDRMProvider | null = null;
-  private videoElement: HTMLVideoElement | null = null;
-  private certificateData: ArrayBuffer | null = null;
-  private pendingSessions: Set<any> = new Set();
-
-  constructor(config: WebDRMConfig) {
-    this.config = config;
-
-    if (config.provider === 'bunny' && config.bunny) {
-      this.bunnyProvider = new BunnyCDNDRMProvider(config.bunny);
-    }
-  }
-
-  /**
-   * Check if FairPlay is supported (Safari only)
-   */
-  isSupported(): boolean {
-    // FairPlay is only supported in Safari
-    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-    return !!(
-      isSafari &&
-      (window as any).WebKitMediaKeys &&
-      navigator.requestMediaKeySystemAccess
-    );
-  }
-
-  /**
-   * Initialize FairPlay DRM system
-   */
-  async initialize(): Promise<void> {
-    if (!this.isSupported()) {
-      throw new DRMError(
-        'FairPlay DRM is not supported in this browser',
-        'FAIRPLAY_NOT_SUPPORTED'
-      );
-    }
-
-    console.log('[FairPlay] Initializing DRM system...');
-
-    try {
-      // Fetch FairPlay certificate
-      this.certificateData = await this.fetchCertificate();
-      console.log('[FairPlay] Certificate loaded:', this.certificateData.byteLength, 'bytes');
-
-    } catch (error) {
-      console.error('[FairPlay] Failed to initialize:', error);
-      throw new DRMError(
-        'Failed to initialize FairPlay DRM',
-        'FAIRPLAY_INIT_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Fetch FairPlay certificate from server
-   */
-  private async fetchCertificate(): Promise<ArrayBuffer> {
-    const certificateUrl = this.getCertificateUrl();
-    const headers = this.getCertificateHeaders();
-
-    console.log('[FairPlay] Fetching certificate from:', certificateUrl);
-
-    try {
-      const response = await fetch(certificateUrl, { headers });
-
-      if (!response.ok) {
-        throw new Error(`Certificate fetch failed: ${response.status} ${response.statusText}`);
-      }
-
-      const certificate = await response.arrayBuffer();
-      return certificate;
-
-    } catch (error) {
-      console.error('[FairPlay] Certificate fetch failed:', error);
-      throw new DRMError(
-        'Failed to fetch FairPlay certificate',
-        'CERTIFICATE_FETCH_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Get certificate URL based on provider
-   */
-  private getCertificateUrl(): string {
-    if (this.config.provider === 'bunny' && this.bunnyProvider) {
-      return this.bunnyProvider.getFairPlayCertificateUrl();
-    } else if (this.config.provider === 'generic' && this.config.generic) {
-      if (!this.config.generic.certificateUrl) {
-        throw new DRMError('FairPlay certificate URL is required', 'NO_CERTIFICATE_URL');
-      }
-      return this.config.generic.certificateUrl;
-    }
-    throw new DRMError('No certificate URL configured', 'NO_CERTIFICATE_URL');
-  }
-
-  /**
-   * Get headers for certificate request
-   */
-  private getCertificateHeaders(): Record<string, string> {
-    if (this.config.provider === 'generic' && this.config.generic?.certificateHeaders) {
-      return this.config.generic.certificateHeaders;
-    }
-    return {};
-  }
-
-  /**
-   * Setup DRM for video element
-   */
-  async setupDRM(videoElement: HTMLVideoElement, manifestUrl: string): Promise<void> {
-    if (!this.certificateData) {
-      throw new DRMError('Certificate not loaded', 'CERTIFICATE_NOT_LOADED');
-    }
-
-    this.videoElement = videoElement;
-
-    // Listen for 'webkitneedkey' event (Safari specific)
-    videoElement.addEventListener('webkitneedkey', this.onWebkitNeedKey.bind(this) as any);
-
-    console.log('[FairPlay] DRM setup complete, waiting for key requests');
-  }
-
-  /**
-   * Handle 'webkitneedkey' event (Safari specific)
-   */
-  private async onWebkitNeedKey(event: any): Promise<void> {
-    console.log('[FairPlay] Key request event received');
-
-    try {
-      if (!this.certificateData || !this.videoElement) {
-        throw new DRMError('DRM not properly initialized', 'DRM_NOT_INITIALIZED');
-      }
-
-      // Extract content ID from init data
-      const contentId = this.extractContentId(event.initData);
-      const keySession = event.target.webkitKeys.createSession('video/mp4', event.initData);
-
-      if (!keySession) {
-        throw new DRMError('Failed to create key session', 'SESSION_CREATE_ERROR');
-      }
-
-      this.pendingSessions.add(keySession);
-
-      // Handle key request message
-      keySession.addEventListener('webkitkeymessage', async (messageEvent: any) => {
-        await this.onKeyMessage(keySession, messageEvent, contentId);
-      });
-
-      // Handle key added
-      keySession.addEventListener('webkitkeyadded', () => {
-        console.log('[FairPlay] Key added successfully');
-        this.pendingSessions.delete(keySession);
-      });
-
-      // Handle key error
-      keySession.addEventListener('webkitkeyerror', () => {
-        console.error('[FairPlay] Key error:', keySession.error);
-        this.pendingSessions.delete(keySession);
-      });
-
-    } catch (error) {
-      console.error('[FairPlay] Failed to handle key request:', error);
-      throw new DRMError(
-        'Failed to process FairPlay key request',
-        'KEY_REQUEST_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Extract content ID from init data
-   */
-  private extractContentId(initData: Uint8Array | ArrayBuffer): string {
-    // Convert init data to string to extract content ID
-    const initDataString = String.fromCharCode.apply(null, Array.from(new Uint8Array(initData)));
-
-    // Extract content ID from URI (format: skd://contentId)
-    const contentIdMatch = initDataString.match(/skd:\/\/([^"'\s]+)/);
-    if (contentIdMatch && contentIdMatch[1]) {
-      return contentIdMatch[1];
-    }
-
-    // Fallback: use entire init data as content ID
-    return initDataString;
-  }
-
-  /**
-   * Handle key message (license request)
-   */
-  private async onKeyMessage(
-    keySession: any,
-    event: any,
-    contentId: string
-  ): Promise<void> {
-    console.log('[FairPlay] Key message received, requesting license');
-
-    try {
-      // Prepare SPC (Server Playback Context) data
-      const spcData = event.message;
-
-      // Request CKC (Content Key Context) from license server
-      const ckcData = await this.requestLicense(spcData, contentId);
-
-      // Update key session with CKC
-      keySession.update(new Uint8Array(ckcData));
-      console.log('[FairPlay] License applied successfully');
-
-    } catch (error) {
-      console.error('[FairPlay] Failed to process license:', error);
-      throw new DRMError(
-        'Failed to process FairPlay license',
-        'LICENSE_PROCESS_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Request license from license server
-   */
-  private async requestLicense(spcData: Uint8Array, contentId: string): Promise<ArrayBuffer> {
-    const licenseUrl = this.getLicenseUrl(contentId);
-    const headers = await this.getLicenseHeaders();
-
-    console.log('[FairPlay] Requesting license from:', licenseUrl);
-
-    try {
-      const response = await fetch(licenseUrl, {
-        method: 'POST',
-        headers: {
-          ...headers,
-          'Content-Type': 'application/octet-stream'
-        },
-        body: spcData
-      });
-
-      if (!response.ok) {
-        throw new Error(`License request failed: ${response.status} ${response.statusText}`);
-      }
-
-      const ckcData = await response.arrayBuffer();
-      console.log('[FairPlay] License received:', ckcData.byteLength, 'bytes');
-
-      return ckcData;
-
-    } catch (error) {
-      console.error('[FairPlay] License request failed:', error);
-      throw new DRMError(
-        'Failed to retrieve FairPlay license',
-        'LICENSE_FETCH_ERROR',
-        error
-      );
-    }
-  }
-
-  /**
-   * Get license URL based on provider
-   */
-  private getLicenseUrl(contentId: string): string {
-    if (this.config.provider === 'bunny' && this.bunnyProvider) {
-      return this.bunnyProvider.getFairPlayLicenseUrl();
-    } 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 || {};
-    }
-    return {};
-  }
-
-  /**
-   * Handle license request (called by DRM manager)
-   */
-  async onLicenseRequest(licenseRequest: ArrayBuffer): Promise<ArrayBuffer> {
-    return await this.requestLicense(new Uint8Array(licenseRequest), '');
-  }
-
-  /**
-   * Cleanup resources
-   */
-  destroy(): void {
-    if (this.videoElement) {
-      this.videoElement.removeEventListener('webkitneedkey', this.onWebkitNeedKey.bind(this) as any);
-      this.videoElement = null;
-    }
-
-    // Close all pending sessions
-    this.pendingSessions.forEach(session => {
-      try {
-        session.close();
-      } catch (e) {
-        // Ignore errors during cleanup
-      }
-    });
-    this.pendingSessions.clear();
-
-    this.certificateData = null;
-    this.bunnyProvider = null;
-  }
-}