unified-video-framework 1.4.412 → 1.4.413

package/packages/web/src/drm/types/DRMTypes.ts

@@ -1,97 +1,91 @@
 /**
- * DRM Types and Interfaces
- * Core types for the web DRM system supporting Bunny CDN and generic DRM providers
+ * DRM Type Definitions
+ * Core type definitions and enums for DRM functionality
  */
 
-// Token provider interface - allows flexible token injection strategies
-export interface DRMTokenProvider {
-  // Get token for manifest/playlist requests
-  getManifestToken(): Promise<DRMToken | null>;
+import { DRMConfig, DRMType } from '@unified-video/core';
 
-  // Get token for media segment requests
-  getSegmentToken(): Promise<DRMToken | null>;
+// Extended DRM configuration for internal use
+export interface ExtendedDRMConfig extends DRMConfig {
+  // Provider-specific settings
+  provider?: 'bunny' | 'generic' | string;
 
-  // Get token for license server requests
-  getLicenseToken(): Promise<DRMToken | null>;
+  // Library/Video IDs for Bunny.net
+  libraryId?: string;
+  videoId?: string;
 
-  // Check if token needs renewal
-  shouldRenewToken(token: DRMToken): boolean;
+  // Advanced options
+  retryConfig?: {
+    maxRetries: number;
+    retryDelay: number;
+  };
 
-  // Refresh/renew token
-  renewToken(token: DRMToken): Promise<DRMToken>;
+  // Debugging
+  debug?: boolean;
 }
 
-// Token structure
-export interface DRMToken {
-  token: string;          // The actual token value
-  expires: number;        // Unix timestamp (seconds)
-  tokenVer?: string;      // Optional token version
+// Browser DRM capabilities
+export interface DRMCapabilities {
+  widevine: boolean;
+  fairplay: boolean;
+  playready: boolean;
+  supportedType: DRMType | null;
 }
 
-// Bunny CDN specific configuration
-export interface BunnyCDNDRMConfig {
-  libraryId: string;                    // Bunny CDN library ID
-  videoId: string;                       // Video ID on Bunny CDN
-  pullZoneUrl: string;                   // e.g., "stream.example.com"
-  tokenProvider: DRMTokenProvider;       // Token provider implementation
-  certificateUrl?: string;               // Override default FairPlay certificate URL
-  licenseUrl?: string;                   // Override default license URL
-  enableReferrerProtection?: boolean;    // Enable referrer header validation
+// License request/response types
+export interface LicenseRequest {
+  url: string;
+  method: 'POST' | 'GET';
+  headers: Record<string, string>;
+  body: ArrayBuffer | string;
+  responseType: 'arraybuffer' | 'text' | 'json';
 }
 
-// Generic DRM configuration (for non-Bunny providers)
-export interface GenericDRMConfig {
-  type: 'widevine' | 'fairplay';
-  licenseUrl: string;
-  certificateUrl?: string;               // Required for FairPlay
-  headers?: Record<string, string>;      // Custom headers for license requests
-  certificateHeaders?: Record<string, string>; // Custom headers for certificate requests
+export interface LicenseResponse {
+  license: ArrayBuffer;
+  metadata?: any;
 }
 
-// Unified DRM configuration
-export interface WebDRMConfig {
-  // Provider type
-  provider: 'bunny' | 'generic';
-
-  // Provider-specific config
-  bunny?: BunnyCDNDRMConfig;
-  generic?: GenericDRMConfig;
+// EME event types
+export interface EMEMessageEvent {
+  messageType: string;
+  message: ArrayBuffer;
 }
 
-// DRM Handler interface (implemented by Widevine and FairPlay handlers)
-export interface IDRMHandler {
-  // Initialize DRM system
-  initialize(): Promise<void>;
-
-  // Setup DRM for video element
-  setupDRM(videoElement: HTMLVideoElement, manifestUrl: string): Promise<void>;
-
-  // Handle license requests
-  onLicenseRequest(licenseRequest: ArrayBuffer): Promise<ArrayBuffer>;
-
-  // Cleanup resources
-  destroy(): void;
-
-  // Check if DRM is supported in current browser
-  isSupported(): boolean;
+// DRM initialization result
+export interface DRMInitResult {
+  success: boolean;
+  drmType: DRMType;
+  keySystem: string;
+  error?: DRMError;
 }
 
-// EME key system identifiers
-export const DRM_KEY_SYSTEMS = {
-  WIDEVINE: 'com.widevine.alpha',
-  FAIRPLAY: 'com.apple.fps.1_0',
-  PLAYREADY: 'com.microsoft.playready',
-  CLEARKEY: 'org.w3.clearkey'
-} as const;
+// DRM-specific errors
+export interface DRMError {
+  code: DRMErrorCode;
+  message: string;
+  fatal: boolean;
+  details?: any;
+  systemError?: any;
+}
 
-// Error types
-export class DRMError extends Error {
-  constructor(
-    message: string,
-    public code: string,
-    public details?: any
-  ) {
-    super(message);
-    this.name = 'DRMError';
-  }
+export enum DRMErrorCode {
+  UNSUPPORTED_BROWSER = 'DRM_UNSUPPORTED_BROWSER',
+  CERTIFICATE_LOAD_FAILED = 'DRM_CERTIFICATE_LOAD_FAILED',
+  LICENSE_REQUEST_FAILED = 'DRM_LICENSE_REQUEST_FAILED',
+  KEY_SYSTEM_ACCESS_DENIED = 'DRM_KEY_SYSTEM_ACCESS_DENIED',
+  MEDIA_KEYS_CREATION_FAILED = 'DRM_MEDIA_KEYS_CREATION_FAILED',
+  SESSION_CREATION_FAILED = 'DRM_SESSION_CREATION_FAILED',
+  LICENSE_INVALID = 'DRM_LICENSE_INVALID',
+  CONFIGURATION_ERROR = 'DRM_CONFIGURATION_ERROR',
+  NETWORK_ERROR = 'DRM_NETWORK_ERROR',
+  TIMEOUT = 'DRM_TIMEOUT',
 }
+
+// Key system mappings
+export const KEY_SYSTEMS: Record<DRMType, string[]> = {
+  [DRMType.WIDEVINE]: ['com.widevine.alpha'],
+  [DRMType.PLAYREADY]: ['com.microsoft.playready', 'com.microsoft.playready.recommendation'],
+  [DRMType.FAIRPLAY]: ['com.apple.fps.1_0', 'com.apple.fps'],
+  [DRMType.CLEARKEY]: ['webkit-org.w3.clearkey', 'org.w3.clearkey'],
+};

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

@@ -0,0 +1,232 @@
+/**
+ * Browser DRM Detector
+ * Detects browser capabilities and determines optimal DRM system
+ */
+
+import { DRMType } from '@unified-video/core';
+import { DRMCapabilities, KEY_SYSTEMS } from '../types/DRMTypes';
+
+export class BrowserDetector {
+  private static instance: BrowserDetector;
+  private capabilities: DRMCapabilities | null = null;
+
+  private constructor() {}
+
+  static getInstance(): BrowserDetector {
+    if (!BrowserDetector.instance) {
+      BrowserDetector.instance = new BrowserDetector();
+    }
+    return BrowserDetector.instance;
+  }
+
+  /**
+   * Detect DRM capabilities of current browser
+   */
+  async detectCapabilities(): Promise<DRMCapabilities> {
+    if (this.capabilities) {
+      return this.capabilities;
+    }
+
+    const capabilities: DRMCapabilities = {
+      widevine: false,
+      fairplay: false,
+      playready: false,
+      supportedType: null,
+    };
+
+    // Check for FairPlay (Safari/iOS) - highest priority on Apple devices
+    if (this.isSafari() || this.isWebKitBased()) {
+      capabilities.fairplay = await this.checkFairPlaySupport();
+      if (capabilities.fairplay) {
+        capabilities.supportedType = DRMType.FAIRPLAY;
+      }
+    }
+
+    // Check for Widevine (Chrome, Firefox, Edge)
+    if (!capabilities.supportedType) {
+      capabilities.widevine = await this.checkWidevineSupport();
+      if (capabilities.widevine) {
+        capabilities.supportedType = DRMType.WIDEVINE;
+      }
+    }
+
+    // Check for PlayReady (Edge, IE)
+    if (!capabilities.supportedType && this.isEdge()) {
+      capabilities.playready = await this.checkPlayReadySupport();
+      if (capabilities.playready) {
+        capabilities.supportedType = DRMType.PLAYREADY;
+      }
+    }
+
+    this.capabilities = capabilities;
+    return capabilities;
+  }
+
+  /**
+   * Get recommended DRM type for current browser
+   */
+  async getRecommendedDRMType(): Promise<DRMType | null> {
+    const caps = await this.detectCapabilities();
+    return caps.supportedType;
+  }
+
+  /**
+   * Check if specific DRM type is supported
+   */
+  async isDRMTypeSupported(drmType: DRMType): Promise<boolean> {
+    const caps = await this.detectCapabilities();
+    switch (drmType) {
+      case DRMType.WIDEVINE:
+        return caps.widevine;
+      case DRMType.FAIRPLAY:
+        return caps.fairplay;
+      case DRMType.PLAYREADY:
+        return caps.playready;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Check if browser is Safari
+   */
+  private isSafari(): boolean {
+    const ua = navigator.userAgent.toLowerCase();
+    return ua.includes('safari') && !ua.includes('chrome') && !ua.includes('chromium');
+  }
+
+  /**
+   * Check if browser is WebKit-based
+   */
+  private isWebKitBased(): boolean {
+    return 'WebKitMediaKeys' in window;
+  }
+
+  /**
+   * Check if browser is Edge
+   */
+  private isEdge(): boolean {
+    const ua = navigator.userAgent.toLowerCase();
+    return ua.includes('edg/');
+  }
+
+  /**
+   * Check FairPlay support
+   */
+  private async checkFairPlaySupport(): Promise<boolean> {
+    try {
+      // Check for WebKit-specific FairPlay API
+      if ('WebKitMediaKeys' in window) {
+        return true;
+      }
+
+      // Check via EME API
+      if (navigator.requestMediaKeySystemAccess) {
+        const config: MediaKeySystemConfiguration[] = [{
+          initDataTypes: ['sinf', 'skd'],
+          videoCapabilities: [{ contentType: 'application/vnd.apple.mpegurl' }],
+        }];
+
+        for (const keySystem of KEY_SYSTEMS[DRMType.FAIRPLAY]) {
+          try {
+            await navigator.requestMediaKeySystemAccess(keySystem, config);
+            return true;
+          } catch (e) {
+            // Try next key system
+            continue;
+          }
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check Widevine support
+   */
+  private async checkWidevineSupport(): Promise<boolean> {
+    try {
+      if (!navigator.requestMediaKeySystemAccess) {
+        return false;
+      }
+
+      const config: MediaKeySystemConfiguration[] = [{
+        initDataTypes: ['cenc'],
+        videoCapabilities: [{
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+        }],
+      }];
+
+      for (const keySystem of KEY_SYSTEMS[DRMType.WIDEVINE]) {
+        try {
+          await navigator.requestMediaKeySystemAccess(keySystem, config);
+          return true;
+        } catch (e) {
+          // Try next key system
+          continue;
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check PlayReady support
+   */
+  private async checkPlayReadySupport(): Promise<boolean> {
+    try {
+      if (!navigator.requestMediaKeySystemAccess) {
+        return false;
+      }
+
+      const config: MediaKeySystemConfiguration[] = [{
+        initDataTypes: ['cenc'],
+        videoCapabilities: [{
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+        }],
+      }];
+
+      for (const keySystem of KEY_SYSTEMS[DRMType.PLAYREADY]) {
+        try {
+          await navigator.requestMediaKeySystemAccess(keySystem, config);
+          return true;
+        } catch (e) {
+          // Try next key system
+          continue;
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get user-friendly browser name
+   */
+  getBrowserName(): string {
+    const ua = navigator.userAgent.toLowerCase();
+
+    if (ua.includes('edg/')) return 'Edge';
+    if (ua.includes('chrome') || ua.includes('chromium')) return 'Chrome';
+    if (ua.includes('firefox')) return 'Firefox';
+    if (ua.includes('safari')) return 'Safari';
+    if (ua.includes('opera') || ua.includes('opr/')) return 'Opera';
+
+    return 'Unknown';
+  }
+
+  /**
+   * Reset cached capabilities (useful for testing)
+   */
+  resetCapabilities(): void {
+    this.capabilities = null;
+  }
+}

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

@@ -0,0 +1,86 @@
+/**
+ * Certificate Manager
+ * Manages FairPlay DRM certificates with in-memory caching
+ */
+
+export class CertificateManager {
+  private static instance: CertificateManager;
+  private cache: Map<string, ArrayBuffer>;
+  private maxCacheSize: number = 10; // Max number of certificates to cache
+
+  private constructor() {
+    this.cache = new Map();
+  }
+
+  static getInstance(): CertificateManager {
+    if (!CertificateManager.instance) {
+      CertificateManager.instance = new CertificateManager();
+    }
+    return CertificateManager.instance;
+  }
+
+  /**
+   * Get certificate from cache
+   */
+  getCertificate(url: string): ArrayBuffer | null {
+    return this.cache.get(url) || null;
+  }
+
+  /**
+   * Store certificate in cache
+   */
+  setCertificate(url: string, certificate: ArrayBuffer): void {
+    // Implement LRU eviction if cache is full
+    if (this.cache.size >= this.maxCacheSize && !this.cache.has(url)) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+
+    this.cache.set(url, certificate);
+  }
+
+  /**
+   * Check if certificate is cached
+   */
+  hasCertificate(url: string): boolean {
+    return this.cache.has(url);
+  }
+
+  /**
+   * Clear all cached certificates
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Remove specific certificate from cache
+   */
+  removeCertificate(url: string): boolean {
+    return this.cache.delete(url);
+  }
+
+  /**
+   * Get cache size
+   */
+  getCacheSize(): number {
+    return this.cache.size;
+  }
+
+  /**
+   * Set max cache size
+   */
+  setMaxCacheSize(size: number): void {
+    this.maxCacheSize = size;
+
+    // Evict old entries if current size exceeds new max
+    while (this.cache.size > this.maxCacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+  }
+}

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