unified-video-framework 1.4.411 → 1.4.413

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

@@ -0,0 +1,84 @@
+/**
+ * DRM Error Handler
+ * Converts DRM errors to user-friendly messages
+ */
+
+import { DRMError, DRMErrorCode } from '../types/DRMTypes';
+
+export class DRMErrorHandler {
+  /**
+   * Get user-friendly error message
+   */
+  static getUserFriendlyMessage(error: DRMError): string {
+    switch (error.code) {
+      case DRMErrorCode.UNSUPPORTED_BROWSER:
+        return 'DRM is not supported in this browser. Please use Chrome, Safari, Firefox, or Edge.';
+
+      case DRMErrorCode.CERTIFICATE_LOAD_FAILED:
+        return 'Failed to load DRM certificate. Please check your internet connection.';
+
+      case DRMErrorCode.LICENSE_REQUEST_FAILED:
+        return 'Failed to obtain content license. Please check your internet connection and try again.';
+
+      case DRMErrorCode.KEY_SYSTEM_ACCESS_DENIED:
+        return 'Access to DRM system was denied. Please ensure DRM is enabled in your browser settings.';
+
+      case DRMErrorCode.MEDIA_KEYS_CREATION_FAILED:
+        return 'Failed to initialize DRM protection. Please try refreshing the page.';
+
+      case DRMErrorCode.SESSION_CREATION_FAILED:
+        return 'Failed to create secure playback session. Please try again.';
+
+      case DRMErrorCode.LICENSE_INVALID:
+        return 'Invalid or expired content license. You may not have permission to view this content.';
+
+      case DRMErrorCode.CONFIGURATION_ERROR:
+        return 'DRM configuration error. Please contact support.';
+
+      case DRMErrorCode.NETWORK_ERROR:
+        return 'Network error while loading protected content. Please check your internet connection.';
+
+      case DRMErrorCode.TIMEOUT:
+        return 'DRM initialization timed out. Please try again.';
+
+      default:
+        return 'An error occurred while loading protected content. Please try again.';
+    }
+  }
+
+  /**
+   * Get technical error message for developers
+   */
+  static getTechnicalMessage(error: DRMError): string {
+    let message = `[${error.code}] ${error.message}`;
+
+    if (error.details) {
+      message += `\nDetails: ${JSON.stringify(error.details, null, 2)}`;
+    }
+
+    if (error.systemError) {
+      message += `\nSystem Error: ${error.systemError}`;
+    }
+
+    return message;
+  }
+
+  /**
+   * Create standardized DRM error
+   */
+  static createError(
+    code: DRMErrorCode,
+    message: string,
+    fatal: boolean = true,
+    details?: any,
+    systemError?: any
+  ): DRMError {
+    return {
+      code,
+      message,
+      fatal,
+      details,
+      systemError,
+    };
+  }
+}

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);
+    }
+  }
+}