tirtc-react-native 2.3.1 → 2.4.0-alpha.4

package/android/src/main/java/com/tange/ai/tirtc/reactnative/TiRtcModule.kt

@@ -1,6 +1,13 @@
 package com.tange.ai.tirtc.reactnative
 
-import android.util.Log
+import android.Manifest
+import android.content.ContentValues
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Environment
+import android.os.Handler
+import android.os.Looper
+import android.provider.MediaStore
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
@@ -13,21 +20,46 @@ import com.tange.ai.tirtc.TiRtcAudioInput
 import com.tange.ai.tirtc.TiRtcAudioOutput
 import com.tange.ai.tirtc.TiRtcConn
 import com.tange.ai.tirtc.TiRtcInitOptions
+import com.tange.ai.tirtc.TiRtcLogging
+import com.tange.ai.tirtc.TiRtcRecordingFile
+import com.tange.ai.tirtc.TiRtcSnapshotFile
 import com.tange.ai.tirtc.TiRtcVideoInput
 import com.tange.ai.tirtc.TiRtcVideoOutput
+import com.tange.ai.tirtc.TiCloudStorage
+import com.tange.ai.tirtc.TiCloudStorageAudioOutput
+import com.tange.ai.tirtc.TiCloudStorageExportRequest
+import com.tange.ai.tirtc.TiCloudStorageRecordingFile
+import com.tange.ai.tirtc.TiCloudStorageRecordingResult
+import com.tange.ai.tirtc.TiCloudStorageReplaySpeed
+import com.tange.ai.tirtc.TiCloudStorageSnapshotFile
+import com.tange.ai.tirtc.TiCloudStorageVideoOutput
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ArrayBlockingQueue
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.RejectedExecutionException
+import java.util.concurrent.ThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
 
 @ReactModule(name = TiRtcModule.NAME)
 class TiRtcModule(
     private val reactContext: ReactApplicationContext,
 ) : NativeTiRtcSpec(reactContext) {
     private val registry = TiRtcReactNativeRegistry
+    private val invalidated = AtomicBoolean(false)
     private val events =
         TiRtcReactNativeEventSink(registry) { event ->
-            reactContext.runOnJSQueueThread {
-                emitOnTiRtcEvent(event)
+            if (!invalidated.get()) {
+                reactContext.runOnJSQueueThread {
+                    if (!invalidated.get()) emitOnTiRtcEvent(event)
+                }
             }
         }
     private val eventBinder = TiRtcReactNativeEventBinder(events)
+    private val nextMediaFileId = AtomicInteger(1)
+    private val mediaFiles = ConcurrentHashMap<Int, Any>()
+    private val mainHandler = Handler(Looper.getMainLooper())
 
     init {
         registry.bindEventSink(events)
@@ -35,13 +67,22 @@ class TiRtcModule(
 
     override fun getName(): String = NAME
 
+    override fun invalidate() {
+        if (!invalidated.compareAndSet(false, true)) return
+        val objects = registry.drain(events)
+        val files = mediaFiles.values.toList()
+        mediaFiles.clear()
+        TiRtcReactNativeCleanup.release(objects, files)
+        super.invalidate()
+    }
+
     @ReactMethod
     override fun initialize(
         options: ReadableMap,
         promise: Promise,
     ) {
         val code =
-            TiRtc.initialize(
+            TiRtc.init(
                 reactContext,
                 TiRtcInitOptions(
                     appId = options.getString("appId") ?: "",
@@ -54,6 +95,11 @@ class TiRtcModule(
 
     override fun shutdown(): Double {
         if (registry.hasLiveObjects()) {
+            TiRtcLogging.w(
+                TAG,
+                "[react_native_shutdown] rejected: dispose all React Native objects before shutdown; " +
+                    "error_code=1007 reason=objects_live",
+            )
             return TiRtcReactNativeErrors.RUNTIME_OBJECTS_LIVE.toDouble()
         }
         return TiRtcReactNativeErrors.normalizeAndroid(TiRtc.shutdown()).toDouble()
@@ -67,16 +113,322 @@ class TiRtcModule(
         message: String,
     ) {
         when (level.toInt()) {
-            0 -> com.tange.ai.tirtc.TiRtcLogging.d(tag, message)
-            1 -> com.tange.ai.tirtc.TiRtcLogging.i(tag, message)
-            2 -> com.tange.ai.tirtc.TiRtcLogging.w(tag, message)
-            3 -> com.tange.ai.tirtc.TiRtcLogging.e(tag, message)
+            0 -> TiRtcLogging.d(tag, message)
+            1 -> TiRtcLogging.i(tag, message)
+            2 -> TiRtcLogging.w(tag, message)
+            3 -> TiRtcLogging.e(tag, message)
+        }
+    }
+
+    @ReactMethod
+    override fun tiCloudStorageInitialize(options: ReadableMap, promise: Promise) {
+        val code = TiCloudStorage.init(
+            reactContext,
+            options.getString("appId") ?: "",
+            options.getString("endpoint") ?: "",
+            options.getBoolean("consoleLogEnabled"),
+        )
+        promise.resolve(code.toDouble())
+    }
+
+    override fun tiCloudStorageShutdown(): Double = TiCloudStorage.shutdown().toDouble()
+
+    override fun tiCloudStorageCreate(token: String): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiCloudStorage(token) },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorage(entry.id, value as TiCloudStorage) },
+        )
+
+    override fun tiCloudStorageUpdateToken(id: Double, token: String): Double =
+        registry.cloudStorage(id.toInt())?.updateToken(token).normalized()
+
+    @ReactMethod
+    override fun tiCloudStorageListRecordings(id: Double, startTimeMs: Double, endTimeMs: Double, promise: Promise) {
+        val cloudStorage = registry.cloudStorage(id.toInt())
+        if (cloudStorage == null) {
+            promise.resolve(tiCloudStorageRecordingsResult(TiRtcReactNativeErrors.OBJECT_RELEASED, emptyList()))
+            return
+        }
+        cloudStorage.listRecordings(startTimeMs.toLong(), endTimeMs.toLong()) { result ->
+            reactContext.runOnJSQueueThread {
+                promise.resolve(tiCloudStorageRecordingsResult(result.code, result.recordings))
+            }
+        }
+    }
+
+    @ReactMethod
+    override fun tiCloudStorageListRecordingDays(
+        id: Double,
+        startDate: String,
+        endDate: String,
+        timeZoneId: String,
+        promise: Promise,
+    ) {
+        val cloudStorage = registry.cloudStorage(id.toInt())
+        if (cloudStorage == null) {
+            promise.resolve(tiCloudStorageRecordingDaysResult(TiRtcReactNativeErrors.OBJECT_RELEASED, emptyList()))
+            return
+        }
+        cloudStorage.listRecordingDays(startDate, endDate, timeZoneId) { result ->
+            reactContext.runOnJSQueueThread {
+                promise.resolve(tiCloudStorageRecordingDaysResult(result.code, result.days))
+            }
+        }
+    }
+
+    override fun tiCloudStorageCreateReplay(id: Double): WritableMap {
+        val cloudStorage = registry.cloudStorage(id.toInt())
+            ?: return createResult(TiRtcReactNativeErrors.OBJECT_RELEASED, 0, 0)
+        return registerReactNativeObject(
+            registry,
+            factory = { cloudStorage.createReplay() },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorageReplay(entry.id, value as com.tange.ai.tirtc.TiCloudStorageReplay) },
+        )
+    }
+
+    override fun tiCloudStorageExportRecording(
+        id: Double,
+        startTimeMs: Double,
+        endTimeMs: Double,
+        videoChannelId: Double,
+        audioChannelId: Double?,
+    ): WritableMap {
+        val cloudStorage = registry.cloudStorage(id.toInt())
+            ?: return recordingStartResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        val bridge = CloudStorageExportBridge(::resolveCloudStorageRecording)
+        val started = cloudStorage.exportRecording(
+            TiCloudStorageExportRequest(
+                startTimeMs.toLong(),
+                endTimeMs.toLong(),
+                videoChannelId.toInt(),
+                audioChannelId?.toInt(),
+            ),
+            null,
+        ) { result -> bridge.complete(result) }
+        val task = started.task ?: return recordingStartResult(started.code, null)
+        bridge.task = task
+        val entry = registry.add(bridge)
+        bridge.onDrained = { registry.release(entry.id) }
+        return recordingStartResult(started.code, entry.id)
+    }
+
+    override fun tiCloudStorageExportProgress(id: Double): Double =
+        registry.tiCloudStorageExportTask(id.toInt())?.task?.progress ?: 0.0
+
+    @ReactMethod
+    override fun tiCloudStorageExportResult(id: Double, promise: Promise) {
+        registry.tiCloudStorageExportTask(id.toInt())?.await(promise)
+            ?: promise.resolve(mp4Result(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null, null))
+    }
+
+    override fun tiCloudStorageExportStop(id: Double): Double =
+        registry.tiCloudStorageExportTask(id.toInt())?.task?.stop().normalized()
+
+    override fun tiCloudStorageDispose(id: Double): Double {
+        val objectId = id.toInt()
+        val code = registry.cloudStorage(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) registry.release(objectId)
+        return code
+    }
+
+    override fun tiCloudStorageReplayGetInfo(id: Double): WritableMap {
+        val replay = registry.tiCloudStorageReplay(id.toInt())
+            ?: return tiCloudStorageReplayInfoResult(TiRtcReactNativeErrors.OBJECT_RELEASED, 0, null)
+        val speed = when (replay.speed) {
+            TiCloudStorageReplaySpeed.X0_125 -> 6
+            TiCloudStorageReplaySpeed.X0_25 -> 5
+            TiCloudStorageReplaySpeed.X0_5 -> 4
+            TiCloudStorageReplaySpeed.X1 -> 0
+            TiCloudStorageReplaySpeed.X2 -> 1
+            TiCloudStorageReplaySpeed.X4 -> 2
+            TiCloudStorageReplaySpeed.X8 -> 3
+        }
+        return tiCloudStorageReplayInfoResult(0, speed, replay.currentTimeMs)
+    }
+
+    override fun tiCloudStorageReplayPlay(
+        id: Double,
+        startTimeMs: Double,
+        endTimeMs: Double,
+        initialTimeMs: Double?,
+    ): Double {
+        val replay = registry.tiCloudStorageReplay(id.toInt()) ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+        return replay.play(startTimeMs.toLong(), endTimeMs.toLong(), initialTimeMs?.toLong()).toDouble()
+    }
+
+    override fun tiCloudStorageReplayPause(id: Double): Double = registry.tiCloudStorageReplay(id.toInt())?.pause().normalized()
+
+    override fun tiCloudStorageReplayResume(id: Double): Double = registry.tiCloudStorageReplay(id.toInt())?.resume().normalized()
+
+    override fun tiCloudStorageReplaySeek(id: Double, timeMs: Double): Double =
+        registry.tiCloudStorageReplay(id.toInt())?.seek(timeMs.toLong()).normalized()
+
+    override fun tiCloudStorageReplaySetSpeed(id: Double, speed: Double): Double {
+        val value = when (speed.toInt()) {
+            6 -> TiCloudStorageReplaySpeed.X0_125
+            5 -> TiCloudStorageReplaySpeed.X0_25
+            4 -> TiCloudStorageReplaySpeed.X0_5
+            0 -> TiCloudStorageReplaySpeed.X1
+            1 -> TiCloudStorageReplaySpeed.X2
+            2 -> TiCloudStorageReplaySpeed.X4
+            3 -> TiCloudStorageReplaySpeed.X8
+            else -> return TiRtcReactNativeErrors.INVALID_ARGUMENT.toDouble()
+        }
+        return registry.tiCloudStorageReplay(id.toInt())?.setSpeed(value).normalized()
+    }
+
+    override fun tiCloudStorageReplayStartRecording(
+        id: Double,
+        videoChannelId: Double,
+        audioChannelId: Double?,
+    ): WritableMap {
+        val replay = registry.tiCloudStorageReplay(id.toInt())
+            ?: return recordingStartResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        val result = replay.startRecording(videoChannelId.toInt(), audioChannelId?.toInt())
+        val entry = result.task?.let(registry::add)
+        return recordingStartResult(result.code, entry?.id)
+    }
+
+    @ReactMethod
+    override fun tiCloudStorageRecordingTaskStop(id: Double, promise: Promise) {
+        val objectId = id.toInt()
+        val task = registry.tiCloudStorageRecordingTask(objectId)
+        if (task == null) {
+            promise.resolve(mp4Result(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null, null))
+            return
+        }
+        task.stop { result ->
+            registry.release(objectId)
+            resolveCloudStorageRecording(promise, result)
+        }
+    }
+
+    override fun tiCloudStorageReplayStop(id: Double): Double = registry.tiCloudStorageReplay(id.toInt())?.stop().normalized()
+
+    override fun tiCloudStorageReplayDispose(id: Double): Double {
+        val objectId = id.toInt()
+        val code = registry.tiCloudStorageReplay(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) registry.release(objectId)
+        return code
+    }
+
+    override fun tiCloudStorageCreateAudioOutput(): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiCloudStorageAudioOutput() },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorageAudioOutput(entry.id, value as TiCloudStorageAudioOutput) },
+        )
+
+    override fun tiCloudStorageAudioOutputGetState(id: Double): WritableMap {
+        val output = registry.tiCloudStorageAudioOutput(id.toInt())
+            ?: return stateResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        return stateResult(0, output.state.name.lowercase())
+    }
+
+    override fun tiCloudStorageAudioOutputSetVolume(id: Double, volumePercent: Double): Double =
+        registry.tiCloudStorageAudioOutput(id.toInt())?.setVolume(volumePercent.toInt()).normalized()
+
+    override fun tiCloudStorageAudioOutputAttach(outputId: Double, replayId: Double, channelId: Double): Double {
+        val replay = registry.tiCloudStorageReplay(replayId.toInt())
+            ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+        return registry.tiCloudStorageAudioOutput(outputId.toInt())?.attach(replay, channelId.toInt()).normalized()
+    }
+
+    override fun tiCloudStorageAudioOutputDetach(outputId: Double): Double =
+        registry.tiCloudStorageAudioOutput(outputId.toInt())?.detach().normalized()
+
+    override fun tiCloudStorageAudioOutputDispose(id: Double): Double {
+        val objectId = id.toInt()
+        val code = registry.tiCloudStorageAudioOutput(objectId)?.dispose().normalized()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) registry.release(objectId)
+        return code
+    }
+
+    override fun tiCloudStorageCreateVideoOutput(): WritableMap =
+        registerReactNativeObject(
+            registry,
+            factory = { TiCloudStorageVideoOutput() },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorageVideoOutput(entry.id, value as TiCloudStorageVideoOutput) },
+        )
+
+    override fun tiCloudStorageVideoOutputGetState(id: Double): WritableMap {
+        val output = registry.tiCloudStorageVideoOutput(id.toInt())
+            ?: return stateResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        return stateResult(0, output.state.name.lowercase())
+    }
+
+    override fun tiCloudStorageVideoOutputAttach(outputId: Double, replayId: Double, channelId: Double): Double {
+        val replay = registry.tiCloudStorageReplay(replayId.toInt())
+            ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+        return registry.tiCloudStorageVideoOutput(outputId.toInt())?.attach(replay, channelId.toInt()).normalized()
+    }
+
+    override fun tiCloudStorageVideoOutputDetach(outputId: Double): Double =
+        registry.tiCloudStorageVideoOutput(outputId.toInt())?.detach().normalized()
+
+    @ReactMethod
+    override fun tiCloudStorageVideoOutputTakeSnapshot(id: Double, promise: Promise) {
+        val output = registry.tiCloudStorageVideoOutput(id.toInt())
+        if (output == null) {
+            promise.resolve(mediaSnapshotResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null))
+            return
+        }
+        output.takeSnapshot { result ->
+            val fileId = result.file?.let { file ->
+                nextMediaFileId.getAndIncrement().also { mediaFiles[it] = file }
+            }
+            reactContext.runOnJSQueueThread {
+                promise.resolve(mediaSnapshotResult(result.code, fileId, result.file?.path))
+            }
+        }
+    }
+
+    override fun tiCloudStorageVideoOutputDispose(id: Double): Double {
+        val objectId = id.toInt()
+        val output = registry.tiCloudStorageVideoOutput(objectId) ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+        val detachCode = detachCloudStorageVideoView(output)
+        val nativeCode = if (detachCode == TiRtcReactNativeErrors.OK) output.dispose() else detachCode
+        val code = TiRtcReactNativeErrors.normalizeAndroid(nativeCode).toDouble()
+        if (code.toInt() == TiRtcReactNativeErrors.OK) registry.release(objectId)
+        return code
+    }
+
+    private fun detachCloudStorageVideoView(output: TiCloudStorageVideoOutput): Int {
+        if (Looper.myLooper() == Looper.getMainLooper()) return output.detachView()
+        val result = AtomicInteger(TiRtcReactNativeErrors.PLATFORM_INTERNAL)
+        val completed = CountDownLatch(1)
+        if (!mainHandler.post {
+                result.set(output.detachView())
+                completed.countDown()
+            }
+        ) {
+            return TiRtcReactNativeErrors.PLATFORM_INTERNAL
+        }
+        return try {
+            if (completed.await(VIEW_DETACH_TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
+                result.get()
+            } else {
+                TiRtcReactNativeErrors.PLATFORM_INTERNAL
+            }
+        } catch (_: InterruptedException) {
+            Thread.currentThread().interrupt()
+            TiRtcReactNativeErrors.PLATFORM_INTERNAL
+        }
+    }
+
+    private fun resolveCloudStorageRecording(promise: Promise, result: TiCloudStorageRecordingResult) {
+        val fileId = result.file?.let { file ->
+            nextMediaFileId.getAndIncrement().also { mediaFiles[it] = file }
+        }
+        reactContext.runOnJSQueueThread {
+            promise.resolve(mp4Result(result.code, fileId, result.file?.path, result.file?.durationMs))
         }
     }
 
     @ReactMethod
     override fun uploadLogs(promise: Promise) {
-        uploadLogsToPromise(promise, TAG)
+        uploadLogsToPromise(promise)
     }
 
     override fun createConn(): WritableMap =
@@ -95,22 +447,9 @@ class TiRtcModule(
         id: Double,
         remoteId: String,
         token: String,
-    ): Double {
-        val objectId = id.toInt()
-        val code = registry.conn(objectId)?.connect(remoteId, token).normalized()
-        Log.i(
-            TAG,
-            "connConnect objectId=$objectId remoteIdPresent=${remoteId.isNotEmpty()} tokenPresent=${token.isNotEmpty()} code=${code.toInt()}",
-        )
-        return code
-    }
+    ): Double = registry.conn(id.toInt())?.connect(remoteId, token).normalized()
 
-    override fun connDisconnect(id: Double): Double {
-        val objectId = id.toInt()
-        val code = registry.conn(objectId)?.disconnect().normalized()
-        Log.i(TAG, "connDisconnect objectId=$objectId code=${code.toInt()}")
-        return code
-    }
+    override fun connDisconnect(id: Double): Double = registry.conn(id.toInt())?.disconnect().normalized()
 
     override fun connSendCommand(
         id: Double,
@@ -143,6 +482,196 @@ class TiRtcModule(
     override fun connRequestKeyFrame(id: Double, streamId: Double): Double =
         registry.conn(id.toInt())?.requestKeyFrame(streamId.toInt()).normalized()
 
+    override fun connStartRecording(id: Double, options: ReadableMap): WritableMap {
+        val conn = registry.conn(id.toInt())
+        if (conn == null) {
+            return recordingStartResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
+        }
+        val result = conn.startRecording(
+            videoStreamId = options.getInt("videoStreamId"),
+            audioStreamId = if (options.isNull("audioStreamId")) null else options.getInt("audioStreamId"),
+        )
+        val entry = result.task?.let { registry.add(it) }
+        return recordingStartResult(result.code, entry?.id)
+    }
+
+    @ReactMethod
+    override fun recordingTaskStop(id: Double, promise: Promise) {
+        val objectId = id.toInt()
+        val task = registry.recordingTask(objectId)
+        if (task == null) {
+            promise.resolve(mp4Result(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null, null))
+            return
+        }
+        task.stop { result ->
+            registry.release(objectId)
+            val fileId = result.file?.let { file ->
+                nextMediaFileId.getAndIncrement().also { mediaFiles[it] = file }
+            }
+            reactContext.runOnJSQueueThread {
+                promise.resolve(mp4Result(result.code, fileId, result.file?.path, result.file?.durationMs))
+            }
+        }
+    }
+
+    @ReactMethod
+    override fun mediaFileMoveToGallery(id: Double, fileName: String?, promise: Promise) {
+        val fileId = id.toInt()
+        val mediaFile = mediaFiles[fileId]
+        val path = when (mediaFile) {
+            is TiRtcRecordingFile -> mediaFile.path
+            is TiRtcSnapshotFile -> mediaFile.path
+            is TiCloudStorageRecordingFile -> mediaFile.path
+            is TiCloudStorageSnapshotFile -> mediaFile.path
+            else -> {
+                promise.resolve(galleryResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null))
+                return
+            }
+        }
+        val video = mediaFile is TiRtcRecordingFile || mediaFile is TiCloudStorageRecordingFile
+        val normalizedName = normalizeGalleryFileName(fileName, video)
+        if (normalizedName == null) {
+            promise.resolve(galleryResult(ERROR_INVALID_ARGUMENT, null))
+            return
+        }
+        if (
+            Build.VERSION.SDK_INT <= Build.VERSION_CODES.P &&
+            reactContext.checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED
+        ) {
+            promise.resolve(galleryResult(ERROR_PERMISSION_DENIED, null))
+            return
+        }
+        try {
+            mediaFileExecutor.execute {
+                publishMediaFile(
+                    fileId,
+                    mediaFile,
+                    path,
+                    video,
+                    normalizedName,
+                    promise,
+                )
+            }
+        } catch (_: RejectedExecutionException) {
+            promise.resolve(galleryResult(ERROR_RESOURCE_EXHAUSTED, null))
+        }
+    }
+
+    private fun publishMediaFile(
+        fileId: Int,
+        mediaFile: Any,
+        path: String,
+        video: Boolean,
+        fileName: String,
+        promise: Promise,
+    ) {
+        val source = java.io.File(path)
+        if (!source.isFile) {
+            reactContext.runOnJSQueueThread { promise.resolve(galleryResult(ERROR_FILE_READ_FAILED, null)) }
+            return
+        }
+        val collection = if (video) MediaStore.Video.Media.EXTERNAL_CONTENT_URI else MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+        val displayName = fileName
+        val legacyTarget = if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            val directory = if (video) Environment.DIRECTORY_MOVIES else Environment.DIRECTORY_PICTURES
+            val targetDirectory = java.io.File(
+                Environment.getExternalStoragePublicDirectory(directory),
+                "TiRTC",
+            )
+            if (!targetDirectory.exists() && !targetDirectory.mkdirs()) {
+                reactContext.runOnJSQueueThread {
+                    promise.resolve(galleryResult(ERROR_FILE_WRITE_FAILED, null))
+                }
+                return
+            }
+            java.io.File(targetDirectory, displayName)
+        } else {
+            null
+        }
+        val values = ContentValues().apply {
+            put(MediaStore.MediaColumns.DISPLAY_NAME, displayName)
+            put(MediaStore.MediaColumns.MIME_TYPE, if (video) "video/mp4" else "image/jpeg")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                put(MediaStore.MediaColumns.RELATIVE_PATH, "${if (video) "Movies" else "Pictures"}/TiRTC")
+                put(MediaStore.MediaColumns.IS_PENDING, 1)
+            } else {
+                @Suppress("DEPRECATION")
+                put(MediaStore.MediaColumns.DATA, legacyTarget!!.absolutePath)
+            }
+        }
+        val resolver = reactContext.contentResolver
+        val target = try {
+            resolver.insert(collection, values)
+        } catch (_: SecurityException) {
+            reactContext.runOnJSQueueThread { promise.resolve(galleryResult(ERROR_PERMISSION_DENIED, null)) }
+            return
+        } catch (_: Throwable) {
+            null
+        }
+        if (target == null) {
+            reactContext.runOnJSQueueThread { promise.resolve(galleryResult(ERROR_FILE_WRITE_FAILED, null)) }
+            return
+        }
+        try {
+            resolver.openOutputStream(target)?.use { output ->
+                source.inputStream().use { input -> input.copyTo(output) }
+            } ?: error("unable to open media asset")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                values.clear()
+                values.put(MediaStore.MediaColumns.IS_PENDING, 0)
+                if (resolver.update(target, values, null, null) != 1) error("unable to publish media asset")
+            }
+        } catch (error: Throwable) {
+            try {
+                resolver.delete(target, null, null)
+            } catch (_: Throwable) {
+            }
+            val code = if (error is SecurityException) ERROR_PERMISSION_DENIED else ERROR_FILE_WRITE_FAILED
+            reactContext.runOnJSQueueThread { promise.resolve(galleryResult(code, null)) }
+            return
+        }
+        val onDelete: (Int) -> Unit = { code ->
+            if (code == 0) {
+                mediaFiles.remove(fileId, mediaFile)
+            } else {
+                try {
+                    resolver.delete(target, null, null)
+                } catch (_: Throwable) {
+                }
+            }
+            reactContext.runOnJSQueueThread {
+                promise.resolve(galleryResult(code, if (code == 0) target.toString() else null))
+            }
+        }
+        when (mediaFile) {
+            is TiRtcRecordingFile -> mediaFile.delete(onDelete)
+            is TiRtcSnapshotFile -> mediaFile.delete(onDelete)
+            is TiCloudStorageRecordingFile -> mediaFile.delete(onDelete)
+            is TiCloudStorageSnapshotFile -> mediaFile.delete(onDelete)
+        }
+    }
+
+    @ReactMethod
+    override fun mediaFileDelete(id: Double, promise: Promise) {
+        val fileId = id.toInt()
+        val mediaFile = mediaFiles[fileId]
+        val callback: (Int) -> Unit = { code ->
+            if (code == 0) mediaFiles.remove(fileId)
+            reactContext.runOnJSQueueThread { promise.resolve(code.toDouble()) }
+        }
+        when (mediaFile) {
+            is TiRtcRecordingFile -> mediaFile.delete(callback)
+            is TiRtcSnapshotFile -> mediaFile.delete(callback)
+            is TiCloudStorageRecordingFile -> mediaFile.delete(callback)
+            is TiCloudStorageSnapshotFile -> mediaFile.delete(callback)
+            else -> promise.resolve(TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble())
+        }
+    }
+
+    override fun mediaFileRelease(id: Double) {
+        mediaFiles.remove(id.toInt())
+    }
+
     override fun connGetMetricsSnapshot(id: Double): WritableMap {
         val conn = registry.conn(id.toInt()) ?: return releasedSnapshotResult()
         return connMetricsResult(conn.getMetricsSnapshot())
@@ -181,6 +710,11 @@ class TiRtcModule(
             volumePercent < 0.0 ||
             volumePercent > 100.0
         ) {
+            TiRtcLogging.w(
+                TAG,
+                "[react_native_audio_output_set_volume] rejected: volume must be an integer from 0 to 100; " +
+                    "error_code=6000 reason=invalid_volume",
+            )
             return TiRtcReactNativeErrors.INVALID_ARGUMENT.toDouble()
         }
         return registry.audioOutput(id.toInt())?.setVolume(volumePercent.toInt()).normalized()
@@ -259,6 +793,23 @@ class TiRtcModule(
         return videoDebugResult(output.getDebugSnapshot())
     }
 
+    @ReactMethod
+    override fun videoOutputTakeSnapshot(id: Double, promise: Promise) {
+        val output = registry.videoOutput(id.toInt())
+        if (output == null) {
+            promise.resolve(mediaSnapshotResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null))
+            return
+        }
+        output.takeSnapshot { snapshotResult ->
+            val fileId = snapshotResult.file?.let { file ->
+                nextMediaFileId.getAndIncrement().also { mediaFiles[it] = file }
+            }
+            reactContext.runOnJSQueueThread {
+                promise.resolve(mediaSnapshotResult(snapshotResult.code, fileId, snapshotResult.file?.path))
+            }
+        }
+    }
+
     override fun videoOutputDispose(id: Double): Double {
         val objectId = id.toInt()
         val code = registry.videoOutput(objectId)?.dispose().normalized()
@@ -310,7 +861,6 @@ class TiRtcModule(
                         ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
                 )
             }
-        Log.i(TAG, "audioInputAttach objectId=${id.toInt()} connId=${connId.toInt()} streamId=${streamId.toInt()} code=$code")
         promise.resolve(code.toDouble())
     }
 
@@ -324,7 +874,6 @@ class TiRtcModule(
                 registry.audioInput(id.toInt())?.start()
                     ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
             )
-        Log.i(TAG, "audioInputStart objectId=${id.toInt()} code=$code")
         promise.resolve(code.toDouble())
     }
 
@@ -420,7 +969,6 @@ class TiRtcModule(
                         ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
                 )
             }
-        Log.i(TAG, "videoInputAttach objectId=${id.toInt()} connId=${connId.toInt()} streamId=${streamId.toInt()} code=$code")
         promise.resolve(code.toDouble())
     }
 
@@ -434,7 +982,6 @@ class TiRtcModule(
                 registry.videoInput(id.toInt())?.start()
                     ?: TiRtcReactNativeErrors.OBJECT_RELEASED,
             )
-        Log.i(TAG, "videoInputStart objectId=${id.toInt()} code=$code")
         promise.resolve(code.toDouble())
     }
 
@@ -478,5 +1025,52 @@ class TiRtcModule(
     companion object {
         const val NAME = "TiRtc"
         private const val TAG = "TiRtcReactNative"
+        private const val VIEW_DETACH_TIMEOUT_SECONDS = 5L
+        private const val ERROR_INVALID_ARGUMENT = 6000
+        private const val ERROR_PERMISSION_DENIED = 6024
+        private const val ERROR_RESOURCE_EXHAUSTED = 6043
+        private const val ERROR_FILE_READ_FAILED = 6045
+        private const val ERROR_FILE_WRITE_FAILED = 6046
+        private val mediaFileExecutor =
+            ThreadPoolExecutor(
+                1,
+                2,
+                30L,
+                TimeUnit.SECONDS,
+                ArrayBlockingQueue(16),
+                { work -> Thread(work, "tirtc-rn-media-file").apply { isDaemon = true } },
+                ThreadPoolExecutor.AbortPolicy(),
+            )
+
+        private fun normalizeGalleryFileName(fileName: String?, video: Boolean): String? {
+            if (fileName == null) {
+                return "${System.currentTimeMillis()}.${if (video) "mp4" else "jpg"}"
+            }
+            if (
+                fileName.isEmpty() ||
+                fileName.isBlank() ||
+                fileName == "." ||
+                fileName == ".." ||
+                fileName.contains('/') ||
+                fileName.contains('\\') ||
+                fileName.contains('\u0000')
+            ) {
+                return null
+            }
+            val extension = if (video) ".mp4" else ".jpg"
+            val stem: String
+            val normalized: String
+            if (fileName.endsWith(extension, ignoreCase = true)) {
+                stem = fileName.dropLast(extension.length)
+                normalized = fileName
+            } else if (fileName.contains('.')) {
+                return null
+            } else {
+                stem = fileName
+                normalized = fileName + extension
+            }
+            val stemBytes = stem.toByteArray(Charsets.UTF_8).size
+            return normalized.takeIf { stemBytes in 1..200 }
+        }
     }
 }