react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/AudioRecorder.kt

@@ -0,0 +1,506 @@
+package com.customcamera
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.MediaRecorder
+import android.util.Log
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.Looper
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.io.File
+import java.io.IOException
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Singleton that manages audio recording using Android's native MediaRecorder API.
+ *
+ * No third-party libraries are used — only android.media.MediaRecorder, which is
+ * part of the Android SDK. Supports pause/resume (API 24+), amplitude metering
+ * for waveform visualisation, and emits JS events for real-time monitoring.
+ *
+ * Threading model:
+ * - All MediaRecorder operations run on the calling (React Native bridge) thread;
+ *   MediaRecorder is not thread-safe so callers must not overlap invocations.
+ * - Metering runs on a dedicated background HandlerThread.
+ * - JS events fire on the main thread so React Native can consume them immediately.
+ */
+object AudioRecorder {
+
+  private const val TAG = "AudioRecorder"
+  private const val EVENT_AUDIO_RECORDER_STATE = "onAudioRecorderState"
+  private const val EVENT_AUDIO_AMPLITUDE = "onAudioAmplitude"
+
+  /** Current high-level state of the recorder. */
+  enum class State { IDLE, RECORDING, PAUSED, ERROR }
+
+  /** Output format presets that map to [MediaRecorder.OutputFormat] constants. */
+  enum class OutputFormat(val apiLevel: Int = 1) {
+    MPEG_4,
+    AAC_ADTS,
+    AMR_NB,
+    AMR_WB,
+    THREE_GPP;
+
+    internal fun toMediaRecorderFormat(): Int = when (this) {
+      MPEG_4    -> MediaRecorder.OutputFormat.MPEG_4
+      AAC_ADTS  -> MediaRecorder.OutputFormat.AAC_ADTS
+      AMR_NB    -> MediaRecorder.OutputFormat.AMR_NB
+      AMR_WB    -> MediaRecorder.OutputFormat.AMR_WB
+      THREE_GPP -> MediaRecorder.OutputFormat.THREE_GPP
+    }
+  }
+
+  /** Audio encoder presets that map to [MediaRecorder.AudioEncoder] constants. */
+  enum class AudioEncoder {
+    AAC, AMR_NB, AMR_WB, HE_AAC;
+
+    internal fun toMediaRecorderEncoder(): Int = when (this) {
+      AAC    -> MediaRecorder.AudioEncoder.AAC
+      AMR_NB -> MediaRecorder.AudioEncoder.AMR_NB
+      AMR_WB -> MediaRecorder.AudioEncoder.AMR_WB
+      HE_AAC -> MediaRecorder.AudioEncoder.HE_AAC
+    }
+  }
+
+  /** Audio source presets that map to [MediaRecorder.AudioSource] constants. */
+  enum class AudioSource {
+    MIC, CAMCORDER, VOICE_RECOGNITION, VOICE_COMMUNICATION;
+
+    internal fun toMediaRecorderSource(): Int = when (this) {
+      MIC                 -> MediaRecorder.AudioSource.MIC
+      CAMCORDER            -> MediaRecorder.AudioSource.CAMCORDER
+      VOICE_RECOGNITION    -> MediaRecorder.AudioSource.VOICE_RECOGNITION
+      VOICE_COMMUNICATION  -> MediaRecorder.AudioSource.VOICE_COMMUNICATION
+    }
+  }
+
+  /**
+   * Configuration passed from JS when starting a recording.
+   * Every field has a sensible default so JS callers can omit everything.
+   */
+  data class Config(
+    val outputFormat: OutputFormat = OutputFormat.MPEG_4,
+    val audioEncoder: AudioEncoder = AudioEncoder.AAC,
+    val audioSource: AudioSource = AudioSource.MIC,
+    val bitRate: Int = 128000,
+    val sampleRate: Int = 44100,
+    val fileName: String? = null,               // null → auto-generate
+    val meteringIntervalMs: Long = 0L,           // 0 = no metering
+  )
+
+  // ── State ──────────────────────────────────────────────────────────────────
+
+  @Volatile
+  private var state: State = State.IDLE
+
+  @Volatile
+  private var startTimestamp: Long = 0L
+
+  @Volatile
+  private var totalPausedDuration: Long = 0L
+
+  @Volatile
+  private var pauseTimestamp: Long = 0L
+
+  private var mediaRecorder: MediaRecorder? = null
+  private var outputFilePath: String = ""
+  private var activeConfig: Config = Config()
+  private var reactContext: ReactApplicationContext? = null
+
+  // Handler on the main looper for emitting JS events.
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  // Metering thread.
+  private var meteringThread: HandlerThread? = null
+  private var meteringHandler: Handler? = null
+  private var meteringEnabled = false
+
+  // ── Public API ─────────────────────────────────────────────────────────────
+
+  /** Returns the current state. Thread-safe because [state] is volatile. */
+  fun getState(): State = state
+
+  /**
+   * True when the recorder is either recording or paused — i.e. a recording
+   * session is active and stopRecording() should eventually be called.
+   */
+  fun isActive(): Boolean = state == State.RECORDING || state == State.PAUSED
+
+  /**
+   * Must be called once before any recording operation so the singleton can
+   * emit JS events. Safe to call multiple times (overwrites the reference).
+   */
+  fun setReactContext(context: ReactApplicationContext) {
+    reactContext = context
+  }
+
+  /**
+   * Start recording audio to [outputDir] (defaults to the app's cacheDir).
+   *
+   * @param context  Android context (used to resolve dirs).
+   * @param config   Recording parameters.
+   * @return A map containing `{ filePath, mimeType }` for the new recording.
+   * @throws IllegalStateException if already recording.
+   * @throws SecurityException     if RECORD_AUDIO permission is not granted.
+   * @throws IOException           if the output file cannot be created.
+   */
+  @Throws(IllegalStateException::class, SecurityException::class, IOException::class)
+  fun startRecording(context: Context, config: Config = Config()): WritableMap {
+    if (state == State.RECORDING) {
+      throw IllegalStateException("Audio recorder is already recording")
+    }
+
+    // Check permission.
+    if (ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO)
+      != PackageManager.PERMISSION_GRANTED
+    ) {
+      throw SecurityException("RECORD_AUDIO permission is not granted")
+    }
+
+    // Release any lingering recorder from a previous incomplete session.
+    releaseInternal()
+
+    activeConfig = config
+
+    // Determine output file path.
+    val dir = File(context.cacheDir, "audio_recordings").apply { mkdirs() }
+    val fileName = config.fileName
+      ?: "recording_${System.currentTimeMillis()}.${extensionFor(config.outputFormat)}"
+    outputFilePath = File(dir, fileName).absolutePath
+
+    // Configure and start MediaRecorder.
+    val recorder = MediaRecorder()
+    mediaRecorder = recorder
+
+    recorder.setAudioSource(config.audioSource.toMediaRecorderSource())
+    recorder.setOutputFormat(config.outputFormat.toMediaRecorderFormat())
+    recorder.setAudioEncoder(config.audioEncoder.toMediaRecorderEncoder())
+    recorder.setAudioSamplingRate(config.sampleRate)
+    recorder.setAudioEncodingBitRate(config.bitRate)
+    recorder.setOutputFile(outputFilePath)
+
+    recorder.prepare()
+    recorder.start()
+
+    state = State.RECORDING
+    startTimestamp = System.currentTimeMillis()
+    totalPausedDuration = 0L
+    pauseTimestamp = 0L
+
+    // Start metering loop if configured.
+    if (config.meteringIntervalMs > 0L) {
+      startMetering(config.meteringIntervalMs)
+    }
+
+    emitStateEvent()
+    Log.i(TAG, "Recording started → $outputFilePath")
+
+    return Arguments.createMap().apply {
+      putString("filePath", outputFilePath)
+      putString("mimeType", mimeTypeFor(config.outputFormat))
+    }
+  }
+
+  /**
+   * Cancel the current recording and delete the temporary file.
+   *
+   * @return `true` if the temp file was deleted, `false` if no file existed.
+   * @throws IllegalStateException if no recording is active.
+   */
+  @Throws(IllegalStateException::class)
+  fun cancelRecording(): Boolean {
+    if (!isActive()) {
+      throw IllegalStateException("No active recording to cancel")
+    }
+
+    val filePath = outputFilePath
+
+    stopMetering()
+
+    try {
+      mediaRecorder?.apply {
+        try {
+          stop()
+        } catch (e: RuntimeException) {
+          Log.w(TAG, "MediaRecorder.stop() threw during cancel", e)
+        }
+        release()
+      }
+      mediaRecorder = null
+
+      // Delete the temporary file.
+      val deleted = if (filePath.isNotEmpty()) {
+        val f = File(filePath)
+        if (f.exists()) f.delete() else false
+      } else false
+
+      state = State.IDLE
+      activeConfig = Config()
+      startTimestamp = 0L
+      totalPausedDuration = 0L
+      pauseTimestamp = 0L
+      outputFilePath = ""
+
+      emitStateEvent()
+      Log.i(TAG, "Recording cancelled — temp file deleted=$deleted")
+      return deleted
+    } catch (e: Exception) {
+      state = State.ERROR
+      emitStateEvent()
+      Log.e(TAG, "Error cancelling recording", e)
+      throw e
+    }
+  }
+
+  /**
+   * Stop the current recording session and finalise the audio file.
+   *
+   * @return A map containing the recorded file metadata:
+   *         `{ filePath, durationMs, fileSizeBytes, mimeType }`.
+   * @throws IllegalStateException if no recording is active.
+   */
+  @Throws(IllegalStateException::class)
+  fun stopRecording(): WritableMap {
+    if (!isActive()) {
+      throw IllegalStateException("No active recording to stop")
+    }
+
+    val filePath = outputFilePath
+    val mimeType = mimeTypeFor(activeConfig.outputFormat)
+
+    stopMetering()
+
+    val durationMs: Long
+    val fileSizeBytes: Long
+
+    try {
+      // Stop & release the recorder.
+      mediaRecorder?.apply {
+        try {
+          stop()      // May throw if called while paused on some OEMs; catch and continue.
+        } catch (e: RuntimeException) {
+          Log.w(TAG, "MediaRecorder.stop() threw — file may be incomplete", e)
+        }
+        release()
+      }
+      mediaRecorder = null
+
+      // Calculate effective duration, accounting for pauses.
+      val now = System.currentTimeMillis()
+      if (pauseTimestamp > 0L) {
+        totalPausedDuration += now - pauseTimestamp
+      }
+      durationMs = now - startTimestamp - totalPausedDuration
+
+      // Read final file size.
+      fileSizeBytes = File(filePath).let { if (it.exists()) it.length() else 0L }
+    } catch (e: Exception) {
+      state = State.ERROR
+      emitStateEvent()
+      Log.e(TAG, "Error stopping recording", e)
+      throw e
+    }
+
+    state = State.IDLE
+    emitStateEvent()
+    Log.i(TAG, "Recording stopped — duration=${durationMs}ms size=${fileSizeBytes}bytes")
+
+    return Arguments.createMap().apply {
+      putString("filePath", filePath)
+      putDouble("durationMs", durationMs.toDouble())
+      putDouble("fileSizeBytes", fileSizeBytes.toDouble())
+      putString("mimeType", mimeType)
+    }
+  }
+
+  /**
+   * Pause the current recording.
+   *
+   * Requires API 24+ (Build.VERSION_CODES.N). On older API levels this
+   * throws [UnsupportedOperationException].
+   */
+  @Throws(IllegalStateException::class, UnsupportedOperationException::class)
+  fun pauseRecording() {
+    if (state != State.RECORDING) {
+      throw IllegalStateException("Cannot pause — recorder is not recording (state=$state)")
+    }
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      throw UnsupportedOperationException("Pause/resume requires API 24+")
+    }
+
+    mediaRecorder?.pause()
+    state = State.PAUSED
+    pauseTimestamp = System.currentTimeMillis()
+    stopMetering()
+    emitStateEvent()
+    Log.i(TAG, "Recording paused")
+  }
+
+  /**
+   * Resume a paused recording.
+   *
+   * Requires API 24+. On older API levels this throws [UnsupportedOperationException].
+   */
+  @Throws(IllegalStateException::class, UnsupportedOperationException::class)
+  fun resumeRecording() {
+    if (state != State.PAUSED) {
+      throw IllegalStateException("Cannot resume — recorder is not paused (state=$state)")
+    }
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      throw UnsupportedOperationException("Pause/resume requires API 24+")
+    }
+
+    mediaRecorder?.resume()
+    state = State.RECORDING
+    totalPausedDuration += System.currentTimeMillis() - pauseTimestamp
+    pauseTimestamp = 0L
+
+    if (activeConfig.meteringIntervalMs > 0L) {
+      startMetering(activeConfig.meteringIntervalMs)
+    }
+    emitStateEvent()
+    Log.i(TAG, "Recording resumed")
+  }
+
+  /**
+   * Get the current recording state as a WritableMap suitable for bridging to JS.
+   */
+  fun getStateMap(): WritableMap = Arguments.createMap().apply {
+    putString("state", state.name.lowercase())
+    putString("filePath", outputFilePath)
+    putDouble("durationMs", computeElapsedMs().toDouble())
+    putBoolean("isPauseSupported", Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
+  }
+
+  /**
+   * Get the current maximum amplitude from MediaRecorder (for metering).
+   * Returns 0 if no recorder is active.
+   */
+  fun getAmplitude(): Int {
+    return try {
+      mediaRecorder?.maxAmplitude ?: 0
+    } catch (e: Exception) {
+      0
+    }
+  }
+
+  // ── Metering ───────────────────────────────────────────────────────────────
+
+  /**
+   * Start periodic amplitude sampling on a background thread.
+   * Emits [EVENT_AUDIO_AMPLITUDE] JS events every [intervalMs].
+   */
+  private fun startMetering(intervalMs: Long) {
+    stopMetering()
+    meteringEnabled = true
+
+    meteringThread = HandlerThread("AudioMetering").apply { start() }
+    meteringHandler = Handler(meteringThread!!.looper)
+
+    meteringHandler?.post(object : Runnable {
+      override fun run() {
+        if (!meteringEnabled) return
+        val amp = getAmplitude()
+        emitAmplitudeEvent(amp)
+        meteringHandler?.postDelayed(this, intervalMs)
+      }
+    })
+  }
+
+  /** Stop the metering loop and tear down its thread. */
+  private fun stopMetering() {
+    meteringEnabled = false
+    meteringHandler?.removeCallbacksAndMessages(null)
+    meteringHandler = null
+    meteringThread?.quitSafely()
+    meteringThread = null
+  }
+
+  // ── Internal helpers ───────────────────────────────────────────────────────
+
+  /**
+   * Compute the effective recording duration, excluding paused time.
+   */
+  private fun computeElapsedMs(): Long {
+    if (startTimestamp == 0L) return 0L
+    val now = System.currentTimeMillis()
+    var paused = totalPausedDuration
+    if (pauseTimestamp > 0L) {
+      paused += now - pauseTimestamp
+    }
+    return now - startTimestamp - paused
+  }
+
+  /**
+   * Release the current MediaRecorder without finalising the file.
+   * Called before starting a new recording or during cleanup.
+   */
+  private fun releaseInternal() {
+    stopMetering()
+    try {
+      mediaRecorder?.apply {
+        try {
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            // On API 24+ we can safely stop. On older versions this may throw.
+            try { stop() } catch (_: RuntimeException) {}
+          }
+        } catch (_: Exception) {}
+        release()
+      }
+    } catch (_: Exception) {}
+    mediaRecorder = null
+    state = State.IDLE
+    startTimestamp = 0L
+    totalPausedDuration = 0L
+    pauseTimestamp = 0L
+    outputFilePath = ""
+  }
+
+  /** Emit a state-change event to JS. */
+  private fun emitStateEvent() {
+    val ctx = reactContext ?: return
+    val map = getStateMap()
+    mainHandler.post {
+      try {
+        ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit(EVENT_AUDIO_RECORDER_STATE, map)
+      } catch (_: Exception) {}
+    }
+  }
+
+  /** Emit an amplitude metering event to JS. */
+  private fun emitAmplitudeEvent(amplitude: Int) {
+    val ctx = reactContext ?: return
+    mainHandler.post {
+      try {
+        ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit(EVENT_AUDIO_AMPLITUDE, amplitude)
+      } catch (_: Exception) {}
+    }
+  }
+
+  // ── MIME / extension helpers ───────────────────────────────────────────────
+
+  private fun mimeTypeFor(fmt: OutputFormat): String = when (fmt) {
+    OutputFormat.MPEG_4    -> "audio/mp4"
+    OutputFormat.AAC_ADTS  -> "audio/aac"
+    OutputFormat.AMR_NB    -> "audio/amr"
+    OutputFormat.AMR_WB    -> "audio/amr-wb"
+    OutputFormat.THREE_GPP -> "audio/3gpp"
+  }
+
+  private fun extensionFor(fmt: OutputFormat): String = when (fmt) {
+    OutputFormat.MPEG_4    -> "m4a"
+    OutputFormat.AAC_ADTS  -> "aac"
+    OutputFormat.AMR_NB    -> "amr"
+    OutputFormat.AMR_WB    -> "amr"
+    OutputFormat.THREE_GPP -> "3gp"
+  }
+}