unified-video-framework 1.4.381 → 1.4.383

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

@@ -1,415 +0,0 @@
-/**
- * iOS DRM Protection Implementation
- *
- * Implements Netflix-like content protection for iOS using:
- * - FairPlay Streaming DRM
- * - Screen capture detection via UIScreen.isCaptured
- * - AirPlay support (DRM playback, not mirroring)
- * - External display 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);
-
-/**
- * iOS DRM Protection
- */
-export class iOSDRMProtection 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,
-      ...config,
-    };
-
-    if (!this.config.enabled) {
-      console.log('[DRM-iOS] Protection disabled');
-      return;
-    }
-
-    console.log('[DRM-iOS] Initializing...', this.config);
-
-    try {
-      // Initialize FairPlay DRM
-      if (this.config.licenseServerUrl && this.config.certificateUrl) {
-        await this.initializeFairPlay();
-      }
-
-      // Start screen capture detection
-      if (this.config.blockScreenRecording) {
-        await this.startScreenCaptureDetection();
-      }
-
-      // Initialize AirPlay
-      if (this.config.allowCasting) {
-        await this.initializeAirPlay();
-      }
-
-      // Setup event listeners
-      this.setupEventListeners();
-
-      this.status.isProtected = true;
-      console.log('[DRM-iOS] Protection initialized');
-    } catch (error) {
-      console.error('[DRM-iOS] Initialization failed:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Initialize FairPlay Streaming
-   */
-  private async initializeFairPlay(): Promise<void> {
-    console.log('[DRM-iOS] Initializing FairPlay...');
-
-    const fairPlayConfig = {
-      licenseServerUrl: this.config.licenseServerUrl,
-      certificateUrl: this.config.certificateUrl,
-      licenseHeaders: this.config.licenseHeaders,
-    };
-
-    const result = await DRMProtectionModule.initializeFairPlay(fairPlayConfig);
-
-    if (result.success) {
-      this.status.drmSystem = 'fairplay';
-      console.log('[DRM-iOS] FairPlay initialized successfully');
-    } else {
-      throw {
-        code: DRMErrorCode.FAIRPLAY_NOT_AVAILABLE,
-        message: 'FairPlay initialization failed',
-        platform: 'ios',
-        recoverable: false,
-      };
-    }
-  }
-
-  /**
-   * Start screen capture detection using UIScreen.isCaptured
-   */
-  private async startScreenCaptureDetection(): Promise<void> {
-    console.log('[DRM-iOS] Starting screen capture detection...');
-
-    await DRMProtectionModule.startScreenCaptureDetection();
-    this.status.isScreenRecordingBlocked = true;
-  }
-
-  /**
-   * Initialize AirPlay
-   */
-  private async initializeAirPlay(): Promise<void> {
-    console.log('[DRM-iOS] Initializing AirPlay...');
-
-    await DRMProtectionModule.initializeAirPlay({
-      allowMirroring: false, // Only allow native AirPlay, not screen mirroring
-    });
-  }
-
-  /**
-   * Setup event listeners
-   */
-  private setupEventListeners(): void {
-    // Screen capture detected
-    this.listeners.push(
-      drmEventEmitter.addListener('onScreenCaptureDetected', () => {
-        console.warn('[DRM-iOS] ⚠️ Screen capture detected!');
-        this.status.screenRecordingDetected = true;
-        this.config.onScreenRecordingDetected?.();
-      })
-    );
-
-    // External display detected (mirroring)
-    this.listeners.push(
-      drmEventEmitter.addListener('onExternalDisplayDetected', (event: any) => {
-        console.warn('[DRM-iOS] ⚠️ External display detected:', event);
-        this.status.mirroringDetected = true;
-        this.config.onMirroringDetected?.();
-      })
-    );
-
-    // AirPlay started
-    this.listeners.push(
-      drmEventEmitter.addListener('onAirPlayStarted', (event: any) => {
-        console.log('[DRM-iOS] AirPlay started:', event.deviceName);
-        this.status.isCasting = true;
-        this.status.castDevice = {
-          name: event.deviceName,
-          type: 'airplay',
-        };
-        this.config.onCastingStarted?.(event.deviceName, 'airplay');
-      })
-    );
-
-    // AirPlay ended
-    this.listeners.push(
-      drmEventEmitter.addListener('onAirPlayEnded', () => {
-        console.log('[DRM-iOS] AirPlay ended');
-        this.status.isCasting = false;
-        this.status.castDevice = undefined;
-        this.config.onCastingEnded?.();
-      })
-    );
-
-    // FairPlay license acquired
-    this.listeners.push(
-      drmEventEmitter.addListener('onLicenseAcquired', () => {
-        console.log('[DRM-iOS] FairPlay license acquired');
-        this.config.onLicenseAcquired?.();
-      })
-    );
-
-    // DRM error
-    this.listeners.push(
-      drmEventEmitter.addListener('onDRMError', (error: any) => {
-        console.error('[DRM-iOS] 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 'blockScreenRecording':
-        if (enabled) {
-          this.startScreenCaptureDetection();
-        }
-        break;
-    }
-  }
-
-  /**
-   * Start casting (AirPlay)
-   */
-  async startCasting(deviceId: string): Promise<void> {
-    await DRMProtectionModule.startAirPlay(deviceId);
-  }
-
-  /**
-   * Stop casting
-   */
-  async stopCasting(): Promise<void> {
-    await DRMProtectionModule.stopAirPlay();
-  }
-
-  /**
-   * Get available cast devices
-   */
-  async getAvailableCastDevices(): Promise<CastDevice[]> {
-    const devices = await DRMProtectionModule.getAvailableAirPlayDevices();
-    return devices.map((device: any) => ({
-      id: device.id,
-      name: device.name,
-      type: 'airplay',
-      isAvailable: device.isAvailable,
-      capabilities: {
-        supportsVideo: true,
-        supportsAudio: true,
-        supportsDRM: device.supportsFairPlay,
-        maxResolution: device.maxResolution,
-      },
-    }));
-  }
-
-  /**
-   * Renew license
-   */
-  async renewLicense(): Promise<void> {
-    await DRMProtectionModule.renewFairPlayLicense();
-  }
-
-  /**
-   * Cleanup
-   */
-  dispose(): void {
-    this.listeners.forEach((listener) => listener.remove());
-    this.listeners = [];
-    DRMProtectionModule.dispose();
-    this.status.isProtected = false;
-  }
-}
-
-/**
- * NATIVE iOS MODULE (Swift)
- *
- * File: ios/YourApp/DRMProtectionModule.swift
- *
- * ```swift
- * import Foundation
- * import AVFoundation
- * import React
- *
- * @objc(DRMProtectionModule)
- * class DRMProtectionModule: RCTEventEmitter {
- *
- *     private var screenCaptureObserver: NSObjectProtocol?
- *     private var externalDisplayObserver: NSObjectProtocol?
- *     private var fairPlayResourceLoader: FairPlayResourceLoader?
- *
- *     override static func requiresMainQueueSetup() -> Bool {
- *         return true
- *     }
- *
- *     override func supportedEvents() -> [String]! {
- *         return [
- *             "onScreenCaptureDetected",
- *             "onExternalDisplayDetected",
- *             "onAirPlayStarted",
- *             "onAirPlayEnded",
- *             "onLicenseAcquired",
- *             "onDRMError"
- *         ]
- *     }
- *
- *     @objc
- *     func initializeFairPlay(_ config: NSDictionary, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
- *         guard let licenseServerUrl = config["licenseServerUrl"] as? String,
- *               let certificateUrl = config["certificateUrl"] as? String else {
- *             rejecter("FAIRPLAY_ERROR", "Invalid configuration", nil)
- *             return
- *         }
- *
- *         fairPlayResourceLoader = FairPlayResourceLoader(
- *             licenseServerUrl: licenseServerUrl,
- *             certificateUrl: certificateUrl
- *         )
- *
- *         resolver(["success": true])
- *     }
- *
- *     @objc
- *     func startScreenCaptureDetection(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
- *         if #available(iOS 11.0, *) {
- *             // Monitor UIScreen.isCaptured
- *             screenCaptureObserver = NotificationCenter.default.addObserver(
- *                 forName: UIScreen.capturedDidChangeNotification,
- *                 object: nil,
- *                 queue: .main
- *             ) { [weak self] _ in
- *                 if UIScreen.main.isCaptured {
- *                     print("[DRM] Screen capture detected!")
- *                     self?.sendEvent(withName: "onScreenCaptureDetected", body: ["isCaptured": true])
- *                 }
- *             }
- *
- *             // Monitor external displays
- *             externalDisplayObserver = NotificationCenter.default.addObserver(
- *                 forName: UIScreen.didConnectNotification,
- *                 object: nil,
- *                 queue: .main
- *             ) { [weak self] notification in
- *                 if let screen = notification.object as? UIScreen {
- *                     print("[DRM] External display connected")
- *                     self?.sendEvent(withName: "onExternalDisplayDetected", body: [
- *                         "screenName": screen.debugDescription
- *                     ])
- *                 }
- *             }
- *
- *             resolve(true)
- *         } else {
- *             reject("NOT_SUPPORTED", "Screen capture detection requires iOS 11+", nil)
- *         }
- *     }
- *
- *     @objc
- *     func initializeAirPlay(_ config: NSDictionary, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
- *         // Configure AirPlay
- *         let allowMirroring = config["allowMirroring"] as? Bool ?? false
- *         resolver(true)
- *     }
- *
- *     deinit {
- *         if let observer = screenCaptureObserver {
- *             NotificationCenter.default.removeObserver(observer)
- *         }
- *         if let observer = externalDisplayObserver {
- *             NotificationCenter.default.removeObserver(observer)
- *         }
- *     }
- * }
- *
- * // FairPlay Resource Loader
- * class FairPlayResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
- *     let licenseServerUrl: String
- *     let certificateUrl: String
- *
- *     init(licenseServerUrl: String, certificateUrl: String) {
- *         self.licenseServerUrl = licenseServerUrl
- *         self.certificateUrl = certificateUrl
- *     }
- *
- *     func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
- *         guard let url = loadingRequest.request.url else {
- *             return false
- *         }
- *
- *         // Handle FairPlay license request
- *         // 1. Get certificate from certificateUrl
- *         // 2. Create SPC (Server Playback Context)
- *         // 3. Send to license server
- *         // 4. Get CKC (Content Key Context)
- *         // 5. Provide to AVPlayer
- *
- *         return true
- *     }
- * }
- * ```
- *
- * Info.plist requirements:
- * ```xml
- * <key>NSMicrophoneUsageDescription</key>
- * <string>Required for content protection</string>
- * ```
- */