@apirtc/expo-apirtc-options-plugin 0.0.4 → 0.0.6

package/build/static/kotlin/BlurVideoProcessor.kt

@@ -0,0 +1,448 @@
+package com.reactnativeapirtc
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.renderscript.Allocation
+import android.renderscript.Element
+import android.renderscript.RenderScript
+import android.renderscript.ScriptIntrinsicBlur
+import android.util.Log
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.segmentation.Segmentation
+import com.google.mlkit.vision.segmentation.Segmenter
+import com.google.mlkit.vision.segmentation.selfie.SelfieSegmenterOptions
+import org.webrtc.JavaI420Buffer
+import org.webrtc.VideoFrame
+import org.webrtc.VideoProcessor
+import org.webrtc.VideoSink
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * BlurVideoProcessor implements WebRTC's VideoProcessor interface.
+ *
+ * When set on a VideoSource via videoSource.setVideoProcessor(processor),
+ * it intercepts every camera frame BEFORE it reaches the VideoTrack.
+ *
+ * Flow:
+ *   Camera → VideoProcessor.onFrameCaptured(frame) → process → downstreamSink.onFrame(processedFrame)
+ *                                                                         ↓
+ *                                                              VideoTrack → RTCView + Encoder
+ */
+class BlurVideoProcessor(
+    private val context: Context,
+    private val blurRadius: Float = 20f,
+    private val blurPasses: Int = 1,
+) : VideoProcessor {
+
+    companion object {
+        private const val TAG = "BlurVideoProcessor"
+        private const val SEGMENTATION_INTERVAL = 2
+        private const val SEG_WIDTH = 256
+        private const val SEG_HEIGHT = 192
+        private const val SEGMENTATION_TIMEOUT_MS = 200L
+        private const val SEGMENTATION_TIMEOUT_FIRST_MS = 600L
+        private const val MASK_DECAY = 0.5f
+        private const val MASK_THRESHOLD_LOW = 0.25f
+        private const val MASK_THRESHOLD_HIGH = 0.50f
+    }
+
+    @Volatile
+    private var downstreamSink: VideoSink? = null
+
+    private val enabled = AtomicBoolean(false)
+    private var segmenter: Segmenter? = null
+    private var renderScript: RenderScript? = null
+    private var blurScript: ScriptIntrinsicBlur? = null
+    private var frameCount = 0L
+
+    @Volatile private var cachedMaskBuffer: ByteBuffer? = null
+    @Volatile private var cachedMaskWidth = 0
+    @Volatile private var cachedMaskHeight = 0
+    @Volatile private var previousMaskFloats: FloatArray? = null
+
+    private var blurredBitmap: Bitmap? = null
+    private var compositeBitmap: Bitmap? = null
+
+    // =====================================================================
+    // VideoProcessor interface
+    // =====================================================================
+
+    override fun setSink(sink: VideoSink?) {
+        Log.d(TAG, "setSink called, sink=${if (sink != null) "non-null" else "null"}")
+        downstreamSink = sink
+    }
+
+    override fun onCapturerStarted(success: Boolean) {
+        Log.d(TAG, "onCapturerStarted: success=$success")
+    }
+
+    override fun onCapturerStopped() {
+        Log.d(TAG, "onCapturerStopped")
+    }
+
+    override fun onFrameCaptured(frame: VideoFrame) {
+        val sink = downstreamSink
+        if (sink == null) {
+            Log.w(TAG, "onFrameCaptured: downstreamSink is null")
+            return
+        }
+
+        if (!enabled.get()) {
+            sink.onFrame(frame)
+            return
+        }
+
+        try {
+            val processedFrame = processFrame(frame)
+            if (processedFrame != null) {
+                sink.onFrame(processedFrame)
+                processedFrame.release()
+            } else {
+                sink.onFrame(frame)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in onFrameCaptured, forwarding original", e)
+            sink.onFrame(frame)
+        }
+    }
+
+    fun onFrame(frame: VideoFrame) {
+        onFrameCaptured(frame)
+    }
+
+    // =====================================================================
+    // Enable / Disable
+    // =====================================================================
+
+    fun enable() {
+        if (enabled.getAndSet(true)) return
+        Log.d(TAG, "Enabling blur processor")
+
+        try {
+            val options = SelfieSegmenterOptions.Builder()
+                .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE)
+                .enableRawSizeMask()
+                .build()
+            segmenter = Segmentation.getClient(options)
+            Log.d(TAG, "ML Kit segmenter initialized successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to initialize ML Kit segmenter", e)
+            enabled.set(false)
+            throw e
+        }
+
+        try {
+            renderScript = RenderScript.create(context)
+            blurScript = ScriptIntrinsicBlur.create(renderScript, Element.U8_4(renderScript))
+            blurScript?.setRadius(blurRadius.coerceIn(1f, 25f))
+            Log.d(TAG, "RenderScript initialized successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to initialize RenderScript", e)
+            segmenter?.close()
+            segmenter = null
+            enabled.set(false)
+            throw e
+        }
+
+        frameCount = 0
+        cachedMaskBuffer = null
+        Log.d(TAG, "Blur processor enabled")
+    }
+
+    fun disable() {
+        if (!enabled.getAndSet(false)) return
+        Log.d(TAG, "Disabling blur processor")
+
+        segmenter?.close()
+        segmenter = null
+        blurScript?.destroy()
+        blurScript = null
+        renderScript?.destroy()
+        renderScript = null
+
+        blurredBitmap?.recycle()
+        blurredBitmap = null
+        compositeBitmap?.recycle()
+        compositeBitmap = null
+        cachedMaskBuffer = null
+        previousMaskFloats = null
+
+        Log.d(TAG, "Blur processor disabled")
+    }
+
+    // =====================================================================
+    // Frame Processing Pipeline
+    // =====================================================================
+
+    private fun processFrame(frame: VideoFrame): VideoFrame? {
+        val buffer = frame.buffer
+        buffer.retain()
+
+        try {
+            val width = buffer.width
+            val height = buffer.height
+
+            val bitmap = i420ToBitmap(buffer, width, height)
+            if (bitmap == null) {
+                Log.w(TAG, "Failed to convert frame to bitmap")
+                return null
+            }
+
+            frameCount++
+
+            if (frameCount % SEGMENTATION_INTERVAL == 0L || cachedMaskBuffer == null) {
+                updateSegmentationMask(bitmap)
+            }
+
+            val mask = cachedMaskBuffer
+            if (mask == null) {
+                if (frameCount == 1L || frameCount % 30L == 1L) {
+                    Log.w(TAG, "No segmentation mask available yet (frame #$frameCount)")
+                }
+                bitmap.recycle()
+                return null
+            }
+
+            applyBlurComposite(bitmap, width, height, mask, cachedMaskWidth, cachedMaskHeight)
+            bitmap.recycle()
+
+            val comp = compositeBitmap ?: run {
+                Log.e(TAG, "compositeBitmap is null after applyBlurComposite")
+                return null
+            }
+
+            val i420Buffer = bitmapToI420Buffer(comp, width, height)
+            return VideoFrame(i420Buffer, frame.rotation, frame.timestampNs)
+
+        } catch (e: Exception) {
+            Log.e(TAG, "processFrame error", e)
+            return null
+        } finally {
+            buffer.release()
+        }
+    }
+
+    private fun updateSegmentationMask(bitmap: Bitmap) {
+        val seg = segmenter ?: run {
+            Log.e(TAG, "updateSegmentationMask: segmenter is null")
+            return
+        }
+
+        val isFirstMask = cachedMaskBuffer == null
+        val timeout = if (isFirstMask) SEGMENTATION_TIMEOUT_FIRST_MS else SEGMENTATION_TIMEOUT_MS
+
+        try {
+            val scaled = Bitmap.createScaledBitmap(bitmap, SEG_WIDTH, SEG_HEIGHT, true)
+            val input = InputImage.fromBitmap(scaled, 0)
+
+            val result = Tasks.await(
+                seg.process(input),
+                timeout,
+                TimeUnit.MILLISECONDS
+            )
+
+            val maskBuf = result.buffer
+            cachedMaskWidth = result.width
+            cachedMaskHeight = result.height
+            val size = cachedMaskWidth * cachedMaskHeight
+
+            maskBuf.rewind()
+            val rawFloats = FloatArray(size) { if (maskBuf.remaining() >= 4) maskBuf.float else 0f }
+
+            // Max-blend with decayed previous: fills transient holes, ghost fades in 2 frames
+            val prev = previousMaskFloats
+            val blended = if (prev != null && prev.size == size) {
+                FloatArray(size) { i -> maxOf(rawFloats[i], MASK_DECAY * prev[i]) }
+            } else rawFloats
+            previousMaskFloats = blended
+
+            val newMask = ByteBuffer.allocateDirect(size * 4)
+            newMask.order(ByteOrder.nativeOrder())
+            for (f in blended) newMask.putFloat(f)
+            newMask.rewind()
+            cachedMaskBuffer = newMask
+
+            if (scaled !== bitmap) scaled.recycle()
+
+        } catch (e: java.util.concurrent.TimeoutException) {
+            if (isFirstMask) {
+                Log.e(TAG, "Segmentation FIRST-CALL timeout (${timeout}ms) — ML Kit model may not be ready")
+            } else {
+                Log.d(TAG, "Segmentation timeout (${timeout}ms), using cached mask")
+            }
+        } catch (e: Exception) {
+            if (isFirstMask) {
+                Log.e(TAG, "Segmentation FIRST-CALL error", e)
+            } else {
+                Log.w(TAG, "Segmentation error (frame #$frameCount)", e)
+            }
+        }
+    }
+
+    private fun applyBlurComposite(
+        original: Bitmap, width: Int, height: Int,
+        maskBuffer: ByteBuffer, maskWidth: Int, maskHeight: Int
+    ) {
+        val rs = renderScript ?: run {
+            Log.e(TAG, "applyBlurComposite: renderScript is null")
+            return
+        }
+        val blur = blurScript ?: run {
+            Log.e(TAG, "applyBlurComposite: blurScript is null")
+            return
+        }
+
+        if (blurredBitmap == null || blurredBitmap!!.width != width || blurredBitmap!!.height != height) {
+            blurredBitmap?.recycle()
+            blurredBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        }
+        if (compositeBitmap == null || compositeBitmap!!.width != width || compositeBitmap!!.height != height) {
+            compositeBitmap?.recycle()
+            compositeBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        }
+
+        // Multi-pass blur: each pass takes the output of the previous as input.
+        // Intermediate bitmaps are recycled; blurredBitmap receives the final result.
+        var src = original.copy(Bitmap.Config.ARGB_8888, true)
+        repeat(blurPasses) { pass ->
+            val isLast = pass == blurPasses - 1
+            val dst = if (isLast) blurredBitmap!! else Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+            val inAlloc = Allocation.createFromBitmap(rs, src)
+            val outAlloc = Allocation.createFromBitmap(rs, dst)
+            blur.setInput(inAlloc)
+            blur.forEach(outAlloc)
+            outAlloc.copyTo(dst)
+            inAlloc.destroy()
+            outAlloc.destroy()
+            src.recycle()
+            src = dst
+        }
+
+        val maskPixels = IntArray(maskWidth * maskHeight)
+        maskBuffer.rewind()
+        for (i in maskPixels.indices) {
+            val raw = if (maskBuffer.remaining() >= 4) maskBuffer.float else 0f
+            val conf = when {
+                raw < MASK_THRESHOLD_LOW  -> 0f
+                raw > MASK_THRESHOLD_HIGH -> 1f
+                else -> (raw - MASK_THRESHOLD_LOW) / (MASK_THRESHOLD_HIGH - MASK_THRESHOLD_LOW)
+            }
+            val alpha = (conf * 255).toInt().coerceIn(0, 255)
+            maskPixels[i] = (alpha shl 24) or 0x00FFFFFF
+        }
+        val maskBmp = Bitmap.createBitmap(maskPixels, maskWidth, maskHeight, Bitmap.Config.ARGB_8888)
+        val scaledMask = if (maskWidth != width || maskHeight != height) {
+            val s = Bitmap.createScaledBitmap(maskBmp, width, height, true)
+            maskBmp.recycle()
+            s
+        } else maskBmp
+
+        // Build person layer: original pixels with alpha from mask.
+        // At edges, alpha is partial → lerp between blurred BG and original → no halo.
+        val personBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+        val personCanvas = Canvas(personBitmap)
+        personCanvas.drawBitmap(original, 0f, 0f, null)
+        val dstInPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_IN) }
+        personCanvas.drawBitmap(scaledMask, 0f, 0f, dstInPaint)
+
+        val canvas = Canvas(compositeBitmap!!)
+        canvas.drawBitmap(blurredBitmap!!, 0f, 0f, null)
+        canvas.drawBitmap(personBitmap, 0f, 0f, null)
+        scaledMask.recycle()
+        personBitmap.recycle()
+    }
+
+    // =====================================================================
+    // Color Space Conversions
+    // =====================================================================
+
+    private fun i420ToBitmap(buffer: VideoFrame.Buffer, width: Int, height: Int): Bitmap? {
+        return try {
+            val i420 = buffer.toI420() ?: return null
+
+            val yPlane = i420.dataY
+            val uPlane = i420.dataU
+            val vPlane = i420.dataV
+            val yStride = i420.strideY
+            val uStride = i420.strideU
+            val vStride = i420.strideV
+
+            val nv21 = ByteArray(width * height * 3 / 2)
+
+            for (row in 0 until height) {
+                yPlane.position(row * yStride)
+                yPlane.get(nv21, row * width, width)
+            }
+
+            val chromaHeight = height / 2
+            val chromaWidth = width / 2
+            for (row in 0 until chromaHeight) {
+                for (col in 0 until chromaWidth) {
+                    val nv21Offset = width * height + row * width + col * 2
+                    vPlane.position(row * vStride + col)
+                    nv21[nv21Offset] = vPlane.get()
+                    uPlane.position(row * uStride + col)
+                    nv21[nv21Offset + 1] = uPlane.get()
+                }
+            }
+
+            i420.release()
+
+            val yuvImage = android.graphics.YuvImage(
+                nv21, android.graphics.ImageFormat.NV21, width, height, null
+            )
+            val out = java.io.ByteArrayOutputStream()
+            yuvImage.compressToJpeg(android.graphics.Rect(0, 0, width, height), 85, out)
+            val jpegBytes = out.toByteArray()
+            val decoded = android.graphics.BitmapFactory.decodeByteArray(jpegBytes, 0, jpegBytes.size)
+            decoded?.copy(Bitmap.Config.ARGB_8888, true)?.also {
+                decoded.recycle()
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "I420→Bitmap error", e)
+            null
+        }
+    }
+
+    private fun bitmapToI420Buffer(bitmap: Bitmap, width: Int, height: Int): JavaI420Buffer {
+        val argbBuffer = ByteBuffer.allocateDirect(width * height * 4)
+        bitmap.copyPixelsToBuffer(argbBuffer)
+        argbBuffer.rewind()
+
+        val i420Buffer = JavaI420Buffer.allocate(width, height)
+        val yBuf = i420Buffer.dataY
+        val uBuf = i420Buffer.dataU
+        val vBuf = i420Buffer.dataV
+
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                val idx = (y * width + x) * 4
+                val r = argbBuffer.get(idx).toInt() and 0xFF
+                val g = argbBuffer.get(idx + 1).toInt() and 0xFF
+                val b = argbBuffer.get(idx + 2).toInt() and 0xFF
+
+                // BT.601 RGB → YUV
+                val yVal = ((66 * r + 129 * g + 25 * b + 128) shr 8) + 16
+                yBuf.put(y * i420Buffer.strideY + x, yVal.coerceIn(0, 255).toByte())
+
+                if (y % 2 == 0 && x % 2 == 0) {
+                    val uVal = ((-38 * r - 74 * g + 112 * b + 128) shr 8) + 128
+                    val vVal = ((112 * r - 94 * g - 18 * b + 128) shr 8) + 128
+                    val chromaIdx = (y / 2) * i420Buffer.strideU + (x / 2)
+                    uBuf.put(chromaIdx, uVal.coerceIn(0, 255).toByte())
+                    vBuf.put(chromaIdx, vVal.coerceIn(0, 255).toByte())
+                }
+            }
+        }
+
+        return i420Buffer
+    }
+}

package/build/withAndroidPlugin.d.ts

@@ -1,6 +1,7 @@
 import { ConfigPlugin } from '@expo/config-plugins';
 type PluginProps = {
     enableMediaProjectionService?: boolean;
+    enableVideoEffects?: boolean;
 };
 declare const withAndroidPlugin: ConfigPlugin<PluginProps>;
 export default withAndroidPlugin;

package/build/withAndroidPlugin.js

@@ -50,6 +50,7 @@ const REQUIRED_PERMISSIONS = [
     "android.permission.FOREGROUND_SERVICE_MICROPHONE",
     "android.permission.FOREGROUND_SERVICE_CAMERA"
 ];
+const MLKIT_SEGMENTATION_DEP = 'implementation("com.google.mlkit:segmentation-selfie:16.0.0-beta6")';
 function getAndroidPackagePath(projectRoot) {
     var _a, _b;
     const manifestPath = path.join(projectRoot, 'android/app/src/main/AndroidManifest.xml');
@@ -74,10 +75,15 @@ function getAndroidPackagePath(projectRoot) {
     }
     return path.join(projectRoot, 'android/app/src/main/java', ...packageName.split('.'));
 }
+function getPackageName(projectRoot) {
+    return getAndroidPackagePath(projectRoot)
+        .replace(path.join(projectRoot, 'android/app/src/main/java') + path.sep, '')
+        .split(path.sep)
+        .join('.');
+}
 function copyAndPatchJavaFiles(projectRoot) {
     const srcDir = path.join(__dirname, 'static/java');
     const destDir = getAndroidPackagePath(projectRoot);
-    // Récupère le packageName sous forme de string (ex: com.reactnativeapirtc)
     const packageName = destDir
         .replace(path.join(projectRoot, 'android/app/src/main/java') + path.sep, '')
         .split(path.sep)
@@ -90,13 +96,43 @@ function copyAndPatchJavaFiles(projectRoot) {
         const dest = path.join(destDir, file);
         if (fs.existsSync(src)) {
             let content = fs.readFileSync(src, 'utf8');
-            // Remplace la ligne de package par la bonne valeur
             content = content.replace(/^package\s+[\w.]+;/m, `package ${packageName};`);
             fs.writeFileSync(dest, content, 'utf8');
             console.log(`Copied and patched ${file} to android sources with package: ${packageName}`);
         }
     });
 }
+function copyAndPatchKotlinFiles(projectRoot) {
+    const srcDir = path.join(__dirname, 'static/kotlin');
+    const destDir = getAndroidPackagePath(projectRoot);
+    const packageName = destDir
+        .replace(path.join(projectRoot, 'android/app/src/main/java') + path.sep, '')
+        .split(path.sep)
+        .join('.');
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    const kotlinFiles = [
+        'BackgroundBlurPackage.kt',
+        'BackgroundBlurModule.kt',
+        'BlurVideoProcessor.kt',
+        'BackgroundImageProcessor.kt',
+    ];
+    kotlinFiles.forEach(file => {
+        const src = path.join(srcDir, file);
+        const dest = path.join(destDir, file);
+        if (fs.existsSync(src)) {
+            let content = fs.readFileSync(src, 'utf8');
+            // Kotlin package declaration has no trailing semicolon
+            content = content.replace(/^package\s+[\w.]+/m, `package ${packageName}`);
+            fs.writeFileSync(dest, content, 'utf8');
+            console.log(`Copied and patched ${file} to android sources with package: ${packageName}`);
+        }
+        else {
+            console.warn(`Kotlin source not found: ${src}`);
+        }
+    });
+}
 const withAndroidPermissions = (config) => {
     return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
         const manifest = config.modResults.manifest;
@@ -116,20 +152,28 @@ const withAndroidPermissions = (config) => {
         return config;
     });
 };
+const withMlKitGradleDep = (config) => {
+    return (0, config_plugins_1.withAppBuildGradle)(config, (config) => {
+        if (!config.modResults.contents.includes('segmentation-selfie')) {
+            config.modResults.contents = config.modResults.contents.replace(/(\s*dependencies\s*\{)/, `$1\n    ${MLKIT_SEGMENTATION_DEP}`);
+            console.log('Added ML Kit segmentation-selfie dependency to app/build.gradle');
+        }
+        return config;
+    });
+};
 const withAndroidPlugin = (config, props) => {
     console.error('withAndroidPlugin called with props:', props);
     let updatedConfig = (0, config_plugins_1.withMainApplication)(config, (config) => {
         const mainApplication = config.modResults;
         if (props.enableMediaProjectionService === false) {
-            // If the feature is disabled, we can return early
             console.warn('Media Projection Service is disabled, skipping modifications.');
             return config;
         }
-        // ✅ Ajouter import après la ligne "package com.xxx"
-        if (!mainApplication.contents.includes('import android.util.Log')) {
+        // Add WebRTCModuleOptions import
+        if (!mainApplication.contents.includes('import com.oney.WebRTCModule.WebRTCModuleOptions')) {
             mainApplication.contents = mainApplication.contents.replace(/(package\s+[\w.]+(?:\r?\n))/, `$1\nimport com.oney.WebRTCModule.WebRTCModuleOptions\n`);
         }
-        // ✅ Ajouter le code au début de onCreate()
+        // Add WebRTCModuleOptions code at start of onCreate()
         const onCreateRegex = /override fun onCreate\(\) \{\n/;
         const customCode = [
             '    val options: WebRTCModuleOptions = WebRTCModuleOptions.getInstance()',
@@ -138,14 +182,10 @@ const withAndroidPlugin = (config, props) => {
         if (!mainApplication.contents.includes('WebRTCModuleOptions.getInstance()')) {
             mainApplication.contents = mainApplication.contents.replace(onCreateRegex, match => `${match}${customCode}`);
         }
-        // Ajout du package AppLifecyclePackage dans la liste (compatible Kotlin)
-        // Récupère le packageName automatiquement
+        // Add AppLifecyclePackage import and registration
         const packageName = (() => {
             try {
-                return getAndroidPackagePath(config.modRequest.projectRoot)
-                    .replace(path.join(config.modRequest.projectRoot, 'android/app/src/main/java') + path.sep, '')
-                    .split(path.sep)
-                    .join('.');
+                return getPackageName(config.modRequest.projectRoot);
             }
             catch (_a) {
                 return null;
@@ -157,15 +197,31 @@ const withAndroidPlugin = (config, props) => {
                 mainApplication.contents = mainApplication.contents.replace(/(package\s+[\w.]+(?:\r?\n))/, `$1${importLine}`);
             }
         }
-        if (!mainApplication.contents.includes('packages.add(AppLifecyclePackage())')) {
-            mainApplication.contents = mainApplication.contents.replace(/(val packages = PackageList\(this\)\.packages[\s\S]*?)(\n\s*return packages)/, (match, p1, p2) => {
-                return `${p1}\n    packages.add(AppLifecyclePackage())${p2}`;
-            });
+        if (!mainApplication.contents.includes('add(AppLifecyclePackage())')) {
+            mainApplication.contents = mainApplication.contents.replace(/(\/\/ add\(MyReactNativePackage\(\)\))/, match => `${match}\n          add(AppLifecyclePackage())`);
         }
-        // Copie les fichiers Java natifs nécessaires pour AppLifecyclePackage
+        // Add BackgroundBlurPackage if enableVideoEffects is true
+        if (props.enableVideoEffects !== false) {
+            if (packageName) {
+                const blurImportLine = `import ${packageName}.BackgroundBlurPackage\n`;
+                if (!mainApplication.contents.includes(blurImportLine.trim())) {
+                    mainApplication.contents = mainApplication.contents.replace(/(package\s+[\w.]+(?:\r?\n))/, `$1${blurImportLine}`);
+                }
+            }
+            if (!mainApplication.contents.includes('add(BackgroundBlurPackage())')) {
+                mainApplication.contents = mainApplication.contents.replace(/(\/\/ add\(MyReactNativePackage\(\)\))/, match => `${match}\n          add(BackgroundBlurPackage())`);
+            }
+            // Copy Kotlin native files
+            copyAndPatchKotlinFiles(config.modRequest.projectRoot);
+        }
+        // Copy Java native files
         copyAndPatchJavaFiles(config.modRequest.projectRoot);
         return config;
     });
+    // Add ML Kit Gradle dependency when video effects are enabled
+    if (props.enableVideoEffects !== false) {
+        updatedConfig = withMlKitGradleDep(updatedConfig);
+    }
     updatedConfig = withAndroidPermissions(updatedConfig);
     return updatedConfig;
 };

package/build/withPlugin.d.ts

@@ -1,6 +1,7 @@
 import { ConfigPlugin } from '@expo/config-plugins';
 type PluginProps = {
     enableMediaProjectionService?: boolean;
+    enableVideoEffects?: boolean;
     appleTeamId?: string;
 };
 export declare const withPlugin: ConfigPlugin<PluginProps>;

package/build/withPlugin.js

@@ -9,6 +9,7 @@ const withIosBroadcastExtension_1 = __importDefault(require("./withIosBroadcastE
 const withIosRPKFiles_1 = __importDefault(require("./withIosRPKFiles"));
 const withPlugin = (config, props = {
     enableMediaProjectionService: true,
+    enableVideoEffects: true,
     appleTeamId: process.env.EXPO_APPLE_TEAM_ID || 'APPLE_TEAM_ID_NOT_SET',
 }) => {
     config = (0, withAndroidPlugin_1.default)(config, props);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apirtc/expo-apirtc-options-plugin",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Plugin Expo pour ajouter les features apiRTC dans une application React Native",
   "main": "index.js",
   "keywords": [