react-native-webrtc-nitro 1.0.0

package/android/build.gradle

@@ -0,0 +1,148 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.13.1"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/Webrtc+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Webrtc_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Webrtc_" + name]).toInteger()
+}
+
+android {
+  namespace "com.webrtc"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+        "META-INF",
+        "META-INF/**",
+        "**/libc++_shared.so",
+        "**/libfbjni.so",
+        "**/libjsi.so",
+        "**/libfolly_json.so",
+        "**/libfolly_runtime.so",
+        "**/libglog.so",
+        "**/libhermes.so",
+        "**/libhermes-executor-debug.so",
+        "**/libhermes_executor.so",
+        "**/libreactnative.so",
+        "**/libreactnativejni.so",
+        "**/libturbomodulejsijni.so",
+        "**/libreact_nativemodule_core.so",
+        "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "Webrtc"
+    codegenJavaPackageName = "com.webrtc"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Webrtc_kotlinVersion=2.1.20
+Webrtc_minSdkVersion=23
+Webrtc_targetSdkVersion=35
+Webrtc_compileSdkVersion=34
+Webrtc_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,210 @@
+#include "FFmpeg.hpp"
+#include "FramePipe.hpp"
+#include "WebrtcOnLoad.hpp"
+#include <android/native_window.h>
+#include <android/native_window_jni.h>
+#include <chrono>
+#include <jni.h>
+#include <string>
+
+JavaVM *gJvm = nullptr;
+
+JNIEXPORT auto JNICALL JNI_OnLoad (JavaVM *vm, void *) -> jint
+{
+    gJvm = vm;
+    return margelo::nitro::webrtc::initialize (vm);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_webrtc_HybridWebrtcView_unsubscribe (JNIEnv *, jobject,
+                                              jint subscriptionId)
+{
+    unsubscribe (subscriptionId);
+}
+
+extern "C" JNIEXPORT auto JNICALL
+Java_com_webrtc_HybridWebrtcView_subscribeAudio (JNIEnv *env, jobject,
+                                                 jstring pipeId, jobject track)
+    -> int
+{
+    auto resampler = std::make_shared<FFmpeg::Resampler> ();
+    jobject trackGlobal = env->NewGlobalRef (track);
+
+    FrameCallback callback
+        = [trackGlobal, resampler] (const std::string &, int,
+                                    const FFmpeg::Frame &raw)
+    {
+        JNIEnv *env;
+        gJvm->AttachCurrentThread (&env, nullptr);
+
+        FFmpeg::Frame frame
+            = resampler->resample (raw, AV_SAMPLE_FMT_S16, 48000, 2);
+        auto *sample = reinterpret_cast<const jbyte *> (frame->data[0]);
+        int length = frame->nb_samples * 2 * 2;
+        jbyteArray byteArray = env->NewByteArray (length);
+        env->SetByteArrayRegion (byteArray, 0, length, sample);
+
+        jclass audioTrackCls = env->GetObjectClass (trackGlobal);
+        jmethodID writeMethod
+            = env->GetMethodID (audioTrackCls, "write", "([BII)I");
+        env->CallIntMethod (trackGlobal, writeMethod, byteArray, 0, length);
+    };
+
+    CleanupCallback cleanup = [trackGlobal] (int)
+    {
+        JNIEnv *env;
+        gJvm->AttachCurrentThread (&env, nullptr);
+        env->DeleteGlobalRef (trackGlobal);
+    };
+
+    std::string pipeIdStr (env->GetStringUTFChars (pipeId, nullptr));
+    return subscribe ({ pipeIdStr }, callback);
+}
+
+extern "C" JNIEXPORT auto JNICALL
+Java_com_webrtc_HybridWebrtcView_subscribeVideo (JNIEnv *env, jobject,
+                                                 jstring pipeId,
+                                                 jobject surface) -> jint
+{
+    if (!surface)
+    {
+        return -1;
+    }
+    ANativeWindow *window = ANativeWindow_fromSurface (env, surface);
+    if (!window)
+    {
+        return -1;
+    }
+
+    auto scaler = std::make_shared<FFmpeg::Scaler> ();
+    FrameCallback callback
+        = [window, scaler] (const std::string &, int, const FFmpeg::Frame &raw)
+    {
+        FFmpeg::Frame frame
+            = scaler->scale (raw, AV_PIX_FMT_RGBA, raw->width, raw->height);
+
+        ANativeWindow_setBuffersGeometry (window, frame->width, frame->height,
+                                          WINDOW_FORMAT_RGBA_8888);
+
+        ANativeWindow_Buffer buffer;
+        if (ANativeWindow_lock (window, &buffer, nullptr) < 0)
+        {
+            return;
+        }
+
+        auto *dst = static_cast<uint8_t *> (buffer.bits);
+        for (int y = 0; y < frame->height; ++y)
+        {
+            uint8_t *srcRow = frame->data[0] + y * frame->linesize[0];
+            uint8_t *dstRow = dst + y * buffer.stride * 4;
+            memcpy (dstRow, srcRow, frame->width * 4);
+        }
+
+        ANativeWindow_unlockAndPost (window);
+    };
+    CleanupCallback cleanup
+        = [window] (int) { ANativeWindow_release (window); };
+    std::string pipeIdStr (env->GetStringUTFChars (pipeId, nullptr));
+    return subscribe ({ pipeIdStr }, callback, cleanup);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_webrtc_HybridMicrophone_publishAudio (JNIEnv *env, jobject,
+                                               jstring pipeId,
+                                               jbyteArray audioBuffer,
+                                               jint size)
+
+{
+    auto frame = FFmpeg::Frame (AV_SAMPLE_FMT_S16, 48000, 1, size / 2);
+    jboolean isCopy = JNI_FALSE;
+    jbyte *audioData = env->GetByteArrayElements (audioBuffer, &isCopy);
+    memcpy (frame->data[0], audioData, size);
+    env->ReleaseByteArrayElements (audioBuffer, audioData, JNI_ABORT);
+
+    std::string pipeIdStr (env->GetStringUTFChars (pipeId, nullptr));
+    publish (pipeIdStr, frame);
+}
+
+extern "C" JNIEXPORT void JNICALL Java_com_webrtc_Camera_publishVideo (
+    JNIEnv *env, jobject, jobjectArray pipeIds, jobject image)
+{
+    jclass imageClass = env->GetObjectClass (image);
+    jmethodID getWidthMethod
+        = env->GetMethodID (imageClass, "getWidth", "()I");
+    jmethodID getHeightMethod
+        = env->GetMethodID (imageClass, "getHeight", "()I");
+    jint width = env->CallIntMethod (image, getWidthMethod);
+    jint height = env->CallIntMethod (image, getHeightMethod);
+
+    jmethodID getPlanesMethod = env->GetMethodID (
+        imageClass, "getPlanes", "()[Landroid/media/Image$Plane;");
+    auto planeArray
+        = (jobjectArray)env->CallObjectMethod (image, getPlanesMethod);
+
+    jobject yPlane = env->GetObjectArrayElement (planeArray, 0);
+    jobject uPlane = env->GetObjectArrayElement (planeArray, 1);
+    jobject vPlane = env->GetObjectArrayElement (planeArray, 2);
+    jclass planeClass = env->GetObjectClass (yPlane);
+    jmethodID getBufferMethod = env->GetMethodID (planeClass, "getBuffer",
+                                                  "()Ljava/nio/ByteBuffer;");
+    jmethodID getRowStrideMethod
+        = env->GetMethodID (planeClass, "getRowStride", "()I");
+    jmethodID getPixelStrideMethod
+        = env->GetMethodID (planeClass, "getPixelStride", "()I");
+
+    jobject yByteBuffer = env->CallObjectMethod (yPlane, getBufferMethod);
+    auto *yBufferPtr
+        = static_cast<uint8_t *> (env->GetDirectBufferAddress (yByteBuffer));
+    jint yRowStride = env->CallIntMethod (yPlane, getRowStrideMethod);
+
+    jobject uByteBuffer = env->CallObjectMethod (uPlane, getBufferMethod);
+    auto *uBufferPtr
+        = static_cast<uint8_t *> (env->GetDirectBufferAddress (uByteBuffer));
+    jint uRowStride = env->CallIntMethod (uPlane, getRowStrideMethod);
+    jint uPixelStride = env->CallIntMethod (uPlane, getPixelStrideMethod);
+
+    jobject vByteBuffer = env->CallObjectMethod (vPlane, getBufferMethod);
+    auto *vBufferPtr
+        = static_cast<uint8_t *> (env->GetDirectBufferAddress (vByteBuffer));
+    jint vRowStride = env->CallIntMethod (vPlane, getRowStrideMethod);
+    jint vPixelStride = env->CallIntMethod (vPlane, getPixelStrideMethod);
+
+    FFmpeg::Frame frame (AV_PIX_FMT_NV12, width, height);
+
+    // Copy Y
+    for (int y = 0; y < height; ++y)
+    {
+        memcpy (frame->data[0] + y * frame->linesize[0],
+                yBufferPtr + y * yRowStride, width);
+    }
+
+    // Copy UV
+    for (int y = 0; y < height / 2; ++y)
+    {
+        for (int x = 0; x < width / 2; ++x)
+        {
+            frame->data[1][y * frame->linesize[1] + x * 2]
+                = uBufferPtr[y * uRowStride + x * uPixelStride];
+            frame->data[1][y * frame->linesize[1] + x * 2 + 1]
+                = vBufferPtr[y * vRowStride + x * vPixelStride];
+        }
+    }
+
+    env->DeleteLocalRef (yPlane);
+    env->DeleteLocalRef (uPlane);
+    env->DeleteLocalRef (vPlane);
+    env->DeleteLocalRef (planeArray);
+    env->DeleteLocalRef (imageClass);
+    env->DeleteLocalRef (planeClass);
+
+    jsize pipeIdsLength = env->GetArrayLength (pipeIds);
+    for (jsize i = 0; i < pipeIdsLength; ++i)
+    {
+        auto pipeId = (jstring)env->GetObjectArrayElement (pipeIds, i);
+        const char *cstr = env->GetStringUTFChars (pipeId, nullptr);
+        std::string pipeIdStr (cstr);
+        publish (pipeIdStr, frame);
+        env->ReleaseStringUTFChars (pipeId, cstr);
+        env->DeleteLocalRef (pipeId);
+    }
+}

package/android/src/main/java/com/webrtc/HybridCamera.kt

@@ -0,0 +1,166 @@
+package com.webrtc
+
+import android.content.Context
+import androidx.annotation.Keep
+import android.Manifest
+import android.content.pm.PackageManager
+import android.hardware.camera2.CameraDevice
+import android.hardware.camera2.CameraManager
+import android.hardware.camera2.CameraCaptureSession
+import android.hardware.camera2.CaptureRequest
+import android.media.Image
+import android.media.ImageReader
+import android.graphics.ImageFormat
+import android.os.Handler
+import android.os.HandlerThread
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.webrtc.HybridCameraSpec
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.NitroModules
+
+
+object Camera {
+    private const val DEFAULT_WIDTH = 1280
+    private const val DEFAULT_HEIGHT = 720
+
+    private var cameraDevice: CameraDevice? = null
+    private var captureSession: CameraCaptureSession? = null
+    private var backgroundThread = HandlerThread("CameraBackground")
+    private var imageReader =
+        ImageReader.newInstance(DEFAULT_WIDTH, DEFAULT_HEIGHT, ImageFormat.YUV_420_888, 2)
+    private val pipeIds = mutableSetOf<String>()
+
+    external fun publishVideo(pipeIds: Array<String>, image: Image)
+
+    private val cameraStateCallback = object : CameraDevice.StateCallback() {
+        override fun onOpened(camera: CameraDevice) {
+            cameraDevice = camera
+            val captureRequestBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW)
+            captureRequestBuilder.addTarget(imageReader.surface)
+
+            captureRequestBuilder.set(
+                CaptureRequest.CONTROL_AF_MODE,
+                CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE
+            )
+
+            captureRequestBuilder.set(
+                CaptureRequest.CONTROL_AE_MODE,
+                CaptureRequest.CONTROL_AE_MODE_ON
+            )
+
+            captureRequestBuilder.set(
+                CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,
+                android.util.Range(30, 30)
+            )
+            val captureRequest = captureRequestBuilder.build()
+
+            val sessionStateCallback = object : CameraCaptureSession.StateCallback() {
+                override fun onConfigured(session: CameraCaptureSession) {
+                    captureSession = session
+                    session.setRepeatingRequest(
+                        captureRequest,
+                        null,
+                        Handler(backgroundThread.looper)
+                    )
+                }
+
+                override fun onConfigureFailed(session: CameraCaptureSession) {
+                    throw RuntimeException("Camera configuration failed")
+                }
+            }
+            camera.createCaptureSession(
+                listOf(imageReader.surface),
+                sessionStateCallback,
+                Handler(backgroundThread.looper)
+            )
+        }
+
+        override fun onDisconnected(camera: CameraDevice) {
+            camera.close()
+        }
+
+        override fun onError(camera: CameraDevice, error: Int) {
+            camera.close()
+            throw RuntimeException("Camera run Error!")
+        }
+    }
+
+    @Synchronized
+    fun addPipeId(pipeId: String) {
+        if (pipeIds.contains(pipeId)) {
+            return
+        }
+        pipeIds.add(pipeId)
+        if (pipeIds.size == 1) {
+            startCamera()
+        }
+    }
+
+    @Synchronized
+    fun removePipeId(pipeId: String) {
+        if (!pipeIds.contains(pipeId)) {
+            return
+        }
+        pipeIds.remove(pipeId)
+        if (pipeIds.isEmpty()) {
+            stopCamera()
+        }
+    }
+
+    private fun startCamera() {
+        val context = NitroModules.applicationContext
+            ?: throw RuntimeException("ReactApplicationContext is not available")
+
+        val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+            ?: throw RuntimeException("CameraManager is not available")
+
+        backgroundThread = HandlerThread("CameraBackground")
+        backgroundThread.start()
+
+        val onImageAvailableListener = ImageReader.OnImageAvailableListener { reader ->
+            val image = reader.acquireNextImage()
+            image.use {
+                publishVideo(pipeIds.toTypedArray(), it)
+            }
+        }
+        imageReader.setOnImageAvailableListener(
+            onImageAvailableListener,
+            Handler(backgroundThread.looper)
+        )
+
+        val cameraId = cameraManager.cameraIdList.firstOrNull()
+            ?: throw RuntimeException("Camera not exist!")
+        cameraManager.openCamera(cameraId, cameraStateCallback, Handler(backgroundThread.looper))
+
+    }
+
+    private fun stopCamera() {
+        captureSession?.stopRepeating()
+        captureSession?.close()
+        captureSession = null
+        cameraDevice?.close()
+        cameraDevice = null
+        backgroundThread.quitSafely()
+        backgroundThread.join()
+    }
+}
+
+
+@Keep
+@DoNotStrip
+class HybridCamera : HybridCameraSpec() {
+    private var pipeId: String = ""
+
+    override fun open(pipeId: String): Promise<Unit> {
+        this.pipeId = pipeId
+        return Promise.async {
+            requestPermission(android.Manifest.permission.CAMERA)
+            Camera.addPipeId(pipeId)
+        }
+    }
+
+    override fun dispose() {
+        Camera.removePipeId(pipeId)
+        pipeId = ""
+    }
+}

package/android/src/main/java/com/webrtc/HybridMicrophone.kt

@@ -0,0 +1,85 @@
+package com.webrtc
+
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaRecorder
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.webrtc.HybridMicrophoneSpec
+import kotlinx.coroutines.*
+import com.margelo.nitro.core.Promise
+import android.media.audiofx.AcousticEchoCanceler
+
+@Keep
+@DoNotStrip
+class HybridMicrophone : HybridMicrophoneSpec() {
+    private var audioRecord: AudioRecord? = null
+    private var recordingJob: Job? = null
+    private var pipeId: String = ""
+    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
+    private var aec: AcousticEchoCanceler? = null
+
+    companion object {
+        private const val SAMPLE_RATE = 44100
+        private const val CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO
+        private const val AUDIO_FORMAT = AudioFormat.ENCODING_PCM_16BIT
+        private val BUFFER_SIZE = AudioRecord.getMinBufferSize(
+            SAMPLE_RATE,
+            CHANNEL_CONFIG,
+            AUDIO_FORMAT
+        )
+    }
+
+    external fun publishAudio(pipeId: String, data: ByteArray, size: Int)
+
+    override fun open(pipeId: String): Promise<Unit> {
+        this.pipeId = pipeId
+        return Promise.async {
+            requestPermission(android.Manifest.permission.RECORD_AUDIO)
+
+            audioRecord = AudioRecord(
+                MediaRecorder.AudioSource.VOICE_COMMUNICATION,
+                SAMPLE_RATE,
+                CHANNEL_CONFIG,
+                AUDIO_FORMAT,
+                BUFFER_SIZE
+            )
+
+            val recorder = audioRecord
+                ?: throw RuntimeException("AudioRecord is null")
+
+            if (recorder.state != AudioRecord.STATE_INITIALIZED) {
+                throw RuntimeException("AudioRecord initialization failed")
+            }
+
+            if (AcousticEchoCanceler.isAvailable()) {
+                aec = AcousticEchoCanceler.create(recorder.audioSessionId)
+                aec?.enabled = true
+            }
+
+            recorder.startRecording()
+
+            recordingJob = scope.launch {
+                val buffer = ByteArray(BUFFER_SIZE)
+                while (isActive) {
+                    val readResult = recorder.read(buffer, 0, buffer.size)
+                    if (readResult > 0) {
+                        publishAudio(pipeId, buffer, readResult)
+                    }
+                }
+            }
+        }
+    }
+
+    override fun dispose() {
+        recordingJob?.cancel()
+        recordingJob = null
+
+        audioRecord?.apply {
+            stop()
+            release()
+        }
+        audioRecord = null
+        scope.cancel()
+    }
+}