unified-video-framework 1.4.381 → 1.4.383

package/packages/core/src/interfaces/IDRMProtection.ts

@@ -1,285 +0,0 @@
-/**
- * Netflix-Like DRM Protection Interface
- *
- * Provides comprehensive content protection against:
- * - Screen recording
- * - Audio capture
- * - Screenshots
- *
- * While allowing:
- * - Official casting (Chromecast, AirPlay, Smart TVs)
- */
-
-/**
- * DRM Protection Configuration
- * All features can be enabled/disabled via boolean flags
- */
-export interface IDRMProtectionConfig {
-  /**
-   * Master switch - enables/disables all DRM protection
-   * @default false
-   */
-  enabled: boolean;
-
-  /**
-   * Block screen recording (video capture)
-   * @default true (when enabled)
-   */
-  blockScreenRecording?: boolean;
-
-  /**
-   * Block audio capture (system audio recording)
-   * @default true (when enabled)
-   */
-  blockAudioCapture?: boolean;
-
-  /**
-   * Block screenshots
-   * @default true (when enabled)
-   */
-  blockScreenshots?: boolean;
-
-  /**
-   * Allow official casting (Chromecast, AirPlay, Smart TVs)
-   * @default true (when enabled)
-   */
-  allowCasting?: boolean;
-
-  /**
-   * Block display mirroring (prevent screen sharing apps)
-   * @default true (when enabled)
-   */
-  blockMirroring?: boolean;
-
-  /**
-   * DRM license server URL
-   * Required for Widevine/PlayReady/FairPlay
-   */
-  licenseServerUrl?: string;
-
-  /**
-   * DRM certificate URL (for FairPlay)
-   */
-  certificateUrl?: string;
-
-  /**
-   * Custom headers for license requests
-   */
-  licenseHeaders?: Record<string, string>;
-
-  /**
-   * Widevine security level (Android)
-   * L1 = Hardware-backed DRM (most secure)
-   * L3 = Software DRM
-   * @default 'L1'
-   */
-  widevineSecurityLevel?: 'L1' | 'L3';
-
-  /**
-   * Callback when screen recording is detected
-   */
-  onScreenRecordingDetected?: () => void;
-
-  /**
-   * Callback when screenshot is attempted
-   */
-  onScreenshotAttempted?: () => void;
-
-  /**
-   * Callback when mirroring is detected
-   */
-  onMirroringDetected?: () => void;
-
-  /**
-   * Callback when casting starts
-   */
-  onCastingStarted?: (deviceName: string, deviceType: CastDeviceType) => void;
-
-  /**
-   * Callback when casting ends
-   */
-  onCastingEnded?: () => void;
-
-  /**
-   * Callback when DRM license is acquired
-   */
-  onLicenseAcquired?: () => void;
-
-  /**
-   * Callback when DRM error occurs
-   */
-  onDRMError?: (error: DRMError) => void;
-}
-
-/**
- * Cast device types
- */
-export type CastDeviceType = 'chromecast' | 'airplay' | 'smart_tv' | 'dlna' | 'miracast';
-
-/**
- * DRM Error types
- */
-export interface DRMError {
-  code: DRMErrorCode;
-  message: string;
-  platform: 'web' | 'android' | 'ios';
-  recoverable: boolean;
-  details?: any;
-}
-
-export enum DRMErrorCode {
-  LICENSE_REQUEST_FAILED = 'LICENSE_REQUEST_FAILED',
-  LICENSE_SERVER_UNREACHABLE = 'LICENSE_SERVER_UNREACHABLE',
-  INVALID_LICENSE = 'INVALID_LICENSE',
-  DEVICE_NOT_SUPPORTED = 'DEVICE_NOT_SUPPORTED',
-  WIDEVINE_NOT_AVAILABLE = 'WIDEVINE_NOT_AVAILABLE',
-  FAIRPLAY_NOT_AVAILABLE = 'FAIRPLAY_NOT_AVAILABLE',
-  PLAYREADY_NOT_AVAILABLE = 'PLAYREADY_NOT_AVAILABLE',
-  HARDWARE_DRM_NOT_AVAILABLE = 'HARDWARE_DRM_NOT_AVAILABLE',
-  SCREEN_RECORDING_DETECTED = 'SCREEN_RECORDING_DETECTED',
-  MIRRORING_DETECTED = 'MIRRORING_DETECTED',
-  HDMI_OUTPUT_BLOCKED = 'HDMI_OUTPUT_BLOCKED',
-}
-
-/**
- * DRM Protection Status
- */
-export interface IDRMProtectionStatus {
-  /**
-   * Is DRM protection active
-   */
-  isProtected: boolean;
-
-  /**
-   * Active DRM system (Widevine, FairPlay, PlayReady)
-   */
-  drmSystem: 'widevine' | 'fairplay' | 'playready' | 'none';
-
-  /**
-   * Is screen recording currently blocked
-   */
-  isScreenRecordingBlocked: boolean;
-
-  /**
-   * Is audio capture currently blocked
-   */
-  isAudioCaptureBlocked: boolean;
-
-  /**
-   * Is screenshot currently blocked
-   */
-  isScreenshotBlocked: boolean;
-
-  /**
-   * Is casting active
-   */
-  isCasting: boolean;
-
-  /**
-   * Current cast device (if casting)
-   */
-  castDevice?: {
-    name: string;
-    type: CastDeviceType;
-  };
-
-  /**
-   * Is screen recording detected (may still be attempting to record)
-   */
-  screenRecordingDetected: boolean;
-
-  /**
-   * Is mirroring detected
-   */
-  mirroringDetected: boolean;
-
-  /**
-   * DRM security level (for Widevine)
-   */
-  securityLevel?: 'L1' | 'L3';
-
-  /**
-   * License expiration time (if available)
-   */
-  licenseExpiration?: Date;
-}
-
-/**
- * DRM Protection Controller Interface
- */
-export interface IDRMProtection {
-  /**
-   * Initialize DRM protection
-   */
-  initialize(config: IDRMProtectionConfig): Promise<void>;
-
-  /**
-   * Get current protection status
-   */
-  getStatus(): IDRMProtectionStatus;
-
-  /**
-   * Enable/disable DRM protection
-   */
-  setEnabled(enabled: boolean): void;
-
-  /**
-   * Enable/disable specific protection feature
-   */
-  setFeature(feature: keyof IDRMProtectionConfig, enabled: boolean): void;
-
-  /**
-   * Start casting to device
-   */
-  startCasting(deviceId: string): Promise<void>;
-
-  /**
-   * Stop casting
-   */
-  stopCasting(): Promise<void>;
-
-  /**
-   * Get available cast devices
-   */
-  getAvailableCastDevices(): Promise<CastDevice[]>;
-
-  /**
-   * Renew DRM license
-   */
-  renewLicense(): Promise<void>;
-
-  /**
-   * Cleanup DRM resources
-   */
-  dispose(): void;
-}
-
-/**
- * Cast device information
- */
-export interface CastDevice {
-  id: string;
-  name: string;
-  type: CastDeviceType;
-  isAvailable: boolean;
-  capabilities: {
-    supportsVideo: boolean;
-    supportsAudio: boolean;
-    supportsDRM: boolean;
-    maxResolution?: string;
-  };
-}
-
-/**
- * DRM Key System Configuration
- */
-export interface DRMKeySystemConfig {
-  keySystem: string;
-  licenseServerUrl: string;
-  certificateUrl?: string;
-  headers?: Record<string, string>;
-  audioRobustness?: string;
-  videoRobustness?: string;
-  persistentState?: 'required' | 'optional' | 'not-allowed';
-  distinctiveIdentifier?: 'required' | 'optional' | 'not-allowed';
-}

package/packages/react-native/src/drm/AndroidDRMProtection.ts

@@ -1,419 +0,0 @@
-/**
- * Android DRM Protection Implementation
- *
- * Implements Netflix-like content protection for Android using:
- * - FLAG_SECURE for screenshot/recording prevention
- * - Widevine DRM (L1/L3)
- * - MediaDrm + ExoPlayer
- * - Chromecast support (remote playback, not mirroring)
- * - Display mirroring detection
- */
-
-import { NativeModules, NativeEventEmitter } from 'react-native';
-import {
-  IDRMProtection,
-  IDRMProtectionConfig,
-  IDRMProtectionStatus,
-  CastDevice,
-  DRMErrorCode,
-} from '@unified-video/core';
-
-const { DRMProtectionModule } = NativeModules;
-const drmEventEmitter = new NativeEventEmitter(DRMProtectionModule);
-
-/**
- * Android DRM Protection
- */
-export class AndroidDRMProtection implements IDRMProtection {
-  private config: IDRMProtectionConfig;
-  private status: IDRMProtectionStatus;
-  private listeners: any[] = [];
-
-  constructor() {
-    this.config = { enabled: false };
-    this.status = {
-      isProtected: false,
-      drmSystem: 'none',
-      isScreenRecordingBlocked: false,
-      isAudioCaptureBlocked: false,
-      isScreenshotBlocked: false,
-      isCasting: false,
-      screenRecordingDetected: false,
-      mirroringDetected: false,
-    };
-  }
-
-  /**
-   * Initialize DRM protection
-   */
-  async initialize(config: IDRMProtectionConfig): Promise<void> {
-    this.config = {
-      blockScreenRecording: true,
-      blockAudioCapture: true,
-      blockScreenshots: true,
-      allowCasting: true,
-      blockMirroring: true,
-      widevineSecurityLevel: 'L1',
-      ...config,
-    };
-
-    if (!this.config.enabled) {
-      console.log('[DRM-Android] Protection disabled');
-      return;
-    }
-
-    console.log('[DRM-Android] Initializing...', this.config);
-
-    try {
-      // Enable FLAG_SECURE to block screenshots and screen recording
-      if (this.config.blockScreenshots || this.config.blockScreenRecording) {
-        await DRMProtectionModule.enableFlagSecure(true);
-        this.status.isScreenshotBlocked = true;
-        this.status.isScreenRecordingBlocked = true;
-        console.log('[DRM-Android] FLAG_SECURE enabled');
-      }
-
-      // Initialize Widevine DRM
-      if (this.config.licenseServerUrl) {
-        await this.initializeWidevine();
-      }
-
-      // Start mirroring detection
-      if (this.config.blockMirroring) {
-        await this.startMirroringDetection();
-      }
-
-      // Initialize Chromecast
-      if (this.config.allowCasting) {
-        await this.initializeChromecast();
-      }
-
-      // Setup event listeners
-      this.setupEventListeners();
-
-      this.status.isProtected = true;
-      console.log('[DRM-Android] Protection initialized');
-    } catch (error) {
-      console.error('[DRM-Android] Initialization failed:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Initialize Widevine DRM
-   */
-  private async initializeWidevine(): Promise<void> {
-    console.log('[DRM-Android] Initializing Widevine...');
-
-    const widevineConfig = {
-      licenseServerUrl: this.config.licenseServerUrl,
-      licenseHeaders: this.config.licenseHeaders,
-      securityLevel: this.config.widevineSecurityLevel,
-    };
-
-    const result = await DRMProtectionModule.initializeWidevine(widevineConfig);
-
-    if (result.success) {
-      this.status.drmSystem = 'widevine';
-      this.status.securityLevel = result.securityLevel;
-      console.log(`[DRM-Android] Widevine initialized with security level: ${result.securityLevel}`);
-
-      if (result.securityLevel === 'L3' && this.config.widevineSecurityLevel === 'L1') {
-        console.warn('[DRM-Android] ⚠️ Requested L1 but got L3 - device may not support hardware DRM');
-      }
-    } else {
-      throw {
-        code: DRMErrorCode.WIDEVINE_NOT_AVAILABLE,
-        message: 'Widevine initialization failed',
-        platform: 'android',
-        recoverable: false,
-      };
-    }
-  }
-
-  /**
-   * Start display mirroring detection
-   */
-  private async startMirroringDetection(): Promise<void> {
-    console.log('[DRM-Android] Starting mirroring detection...');
-
-    // Monitor for external displays and mirroring
-    await DRMProtectionModule.startMirroringDetection();
-  }
-
-  /**
-   * Initialize Chromecast
-   */
-  private async initializeChromecast(): Promise<void> {
-    console.log('[DRM-Android] Initializing Chromecast...');
-
-    await DRMProtectionModule.initializeChromecast({
-      appId: 'CC1AD845', // Default Media Receiver
-    });
-  }
-
-  /**
-   * Setup event listeners
-   */
-  private setupEventListeners(): void {
-    // Screen recording detected
-    this.listeners.push(
-      drmEventEmitter.addListener('onScreenRecordingDetected', () => {
-        console.warn('[DRM-Android] ⚠️ Screen recording detected!');
-        this.status.screenRecordingDetected = true;
-        this.config.onScreenRecordingDetected?.();
-      })
-    );
-
-    // Mirroring detected
-    this.listeners.push(
-      drmEventEmitter.addListener('onMirroringDetected', (event: any) => {
-        console.warn('[DRM-Android] ⚠️ Display mirroring detected:', event.displayName);
-        this.status.mirroringDetected = true;
-        this.config.onMirroringDetected?.();
-      })
-    );
-
-    // Casting started
-    this.listeners.push(
-      drmEventEmitter.addListener('onCastingStarted', (event: any) => {
-        console.log('[DRM-Android] Casting started:', event.deviceName);
-        this.status.isCasting = true;
-        this.status.castDevice = {
-          name: event.deviceName,
-          type: 'chromecast',
-        };
-        this.config.onCastingStarted?.(event.deviceName, 'chromecast');
-      })
-    );
-
-    // Casting ended
-    this.listeners.push(
-      drmEventEmitter.addListener('onCastingEnded', () => {
-        console.log('[DRM-Android] Casting ended');
-        this.status.isCasting = false;
-        this.status.castDevice = undefined;
-        this.config.onCastingEnded?.();
-      })
-    );
-
-    // License acquired
-    this.listeners.push(
-      drmEventEmitter.addListener('onLicenseAcquired', (event: any) => {
-        console.log('[DRM-Android] License acquired');
-        this.status.licenseExpiration = event.expirationTime ? new Date(event.expirationTime) : undefined;
-        this.config.onLicenseAcquired?.();
-      })
-    );
-
-    // DRM error
-    this.listeners.push(
-      drmEventEmitter.addListener('onDRMError', (error: any) => {
-        console.error('[DRM-Android] DRM Error:', error);
-        this.config.onDRMError?.(error);
-      })
-    );
-  }
-
-  /**
-   * Get current status
-   */
-  getStatus(): IDRMProtectionStatus {
-    return { ...this.status };
-  }
-
-  /**
-   * Enable/disable protection
-   */
-  setEnabled(enabled: boolean): void {
-    this.config.enabled = enabled;
-    DRMProtectionModule.setEnabled(enabled);
-  }
-
-  /**
-   * Set specific feature
-   */
-  setFeature(feature: keyof IDRMProtectionConfig, enabled: boolean): void {
-    (this.config as any)[feature] = enabled;
-
-    switch (feature) {
-      case 'blockScreenshots':
-      case 'blockScreenRecording':
-        DRMProtectionModule.enableFlagSecure(enabled);
-        this.status.isScreenshotBlocked = enabled;
-        this.status.isScreenRecordingBlocked = enabled;
-        break;
-    }
-  }
-
-  /**
-   * Start casting
-   */
-  async startCasting(deviceId: string): Promise<void> {
-    await DRMProtectionModule.startCasting(deviceId);
-  }
-
-  /**
-   * Stop casting
-   */
-  async stopCasting(): Promise<void> {
-    await DRMProtectionModule.stopCasting();
-  }
-
-  /**
-   * Get available cast devices
-   */
-  async getAvailableCastDevices(): Promise<CastDevice[]> {
-    const devices = await DRMProtectionModule.getAvailableCastDevices();
-    return devices.map((device: any) => ({
-      id: device.id,
-      name: device.name,
-      type: 'chromecast',
-      isAvailable: device.isAvailable,
-      capabilities: {
-        supportsVideo: true,
-        supportsAudio: true,
-        supportsDRM: device.supportsDRM,
-        maxResolution: device.maxResolution,
-      },
-    }));
-  }
-
-  /**
-   * Renew license
-   */
-  async renewLicense(): Promise<void> {
-    await DRMProtectionModule.renewLicense();
-  }
-
-  /**
-   * Cleanup
-   */
-  dispose(): void {
-    this.listeners.forEach((listener) => listener.remove());
-    this.listeners = [];
-    DRMProtectionModule.dispose();
-    this.status.isProtected = false;
-  }
-}
-
-/**
- * NATIVE ANDROID MODULE (Java/Kotlin)
- *
- * File: android/app/src/main/java/com/yourapp/DRMProtectionModule.kt
- *
- * ```kotlin
- * package com.yourapp
- *
- * import android.view.WindowManager
- * import android.hardware.display.DisplayManager
- * import android.media.MediaDrm
- * import com.facebook.react.bridge.*
- * import com.facebook.react.modules.core.DeviceEventManagerModule
- * import com.google.android.gms.cast.framework.CastContext
- * import com.google.android.exoplayer2.drm.*
- *
- * class DRMProtectionModule(reactContext: ReactApplicationContext) :
- *     ReactContextBaseJavaModule(reactContext) {
- *
- *     private val WIDEVINE_UUID = UUID(0xEDEF8BA979D64ACEL, 0xA3C827DCD51D21EDL)
- *     private var mediaDrm: MediaDrm? = null
- *     private var displayManager: DisplayManager? = null
- *
- *     override fun getName(): String = "DRMProtectionModule"
- *
- *     @ReactMethod
- *     fun enableFlagSecure(enabled: Boolean, promise: Promise) {
- *         try {
- *             currentActivity?.runOnUiThread {
- *                 val window = currentActivity?.window
- *                 if (enabled) {
- *                     window?.setFlags(
- *                         WindowManager.LayoutParams.FLAG_SECURE,
- *                         WindowManager.LayoutParams.FLAG_SECURE
- *                     )
- *                 } else {
- *                     window?.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
- *                 }
- *             }
- *             promise.resolve(true)
- *         } catch (e: Exception) {
- *             promise.reject("FLAG_SECURE_ERROR", e.message)
- *         }
- *     }
- *
- *     @ReactMethod
- *     fun initializeWidevine(config: ReadableMap, promise: Promise) {
- *         try {
- *             mediaDrm = MediaDrm(WIDEVINE_UUID)
- *
- *             val securityLevel = mediaDrm?.getPropertyString("securityLevel")
- *             val hdcpLevel = mediaDrm?.getPropertyString("hdcpLevel")
- *
- *             val result = Arguments.createMap().apply {
- *                 putBoolean("success", true)
- *                 putString("securityLevel", securityLevel)
- *                 putString("hdcpLevel", hdcpLevel)
- *             }
- *
- *             promise.resolve(result)
- *         } catch (e: Exception) {
- *             promise.reject("WIDEVINE_ERROR", e.message)
- *         }
- *     }
- *
- *     @ReactMethod
- *     fun startMirroringDetection(promise: Promise) {
- *         try {
- *             displayManager = reactApplicationContext
- *                 .getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
- *
- *             val callback = object : DisplayManager.DisplayListener {
- *                 override fun onDisplayAdded(displayId: Int) {
- *                     val display = displayManager?.getDisplay(displayId)
- *                     if (display != null && display.displayId != Display.DEFAULT_DISPLAY) {
- *                         // External display detected - could be mirroring
- *                         sendEvent("onMirroringDetected", Arguments.createMap().apply {
- *                             putInt("displayId", displayId)
- *                             putString("displayName", display.name)
- *                         })
- *                     }
- *                 }
- *
- *                 override fun onDisplayRemoved(displayId: Int) {}
- *                 override fun onDisplayChanged(displayId: Int) {}
- *             }
- *
- *             displayManager?.registerDisplayListener(callback, null)
- *             promise.resolve(true)
- *         } catch (e: Exception) {
- *             promise.reject("MIRRORING_DETECTION_ERROR", e.message)
- *         }
- *     }
- *
- *     @ReactMethod
- *     fun initializeChromecast(config: ReadableMap, promise: Promise) {
- *         try {
- *             // Initialize Google Cast
- *             CastContext.getSharedInstance(reactApplicationContext)
- *             promise.resolve(true)
- *         } catch (e: Exception) {
- *             promise.reject("CHROMECAST_ERROR", e.message)
- *         }
- *     }
- *
- *     private fun sendEvent(eventName: String, params: WritableMap) {
- *         reactApplicationContext
- *             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
- *             .emit(eventName, params)
- *     }
- * }
- * ```
- *
- * MANIFEST PERMISSIONS:
- * ```xml
- * <uses-permission android:name="android.permission.INTERNET" />
- * <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
- * <uses-permission android:name="com.google.android.gms.permission.AD_ID" />
- * ```
- */