unified-video-framework 1.4.377 → 1.4.378

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

@@ -0,0 +1,419 @@
+/**
+ * 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" />
+ * ```
+ */