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

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

@@ -0,0 +1,115 @@
+package com.tange.ai.tirtc.reactnative
+
+import android.os.Handler
+import android.os.Looper
+import com.tange.ai.tirtc.TiRtc
+import com.tange.ai.tirtc.TiRtcAudioInput
+import com.tange.ai.tirtc.TiRtcAudioOutput
+import com.tange.ai.tirtc.TiRtcConn
+import com.tange.ai.tirtc.TiRtcLogging
+import com.tange.ai.tirtc.TiRtcRecordingFile
+import com.tange.ai.tirtc.TiRtcRecordingTask
+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.TiCloudStorageRecordingFile
+import com.tange.ai.tirtc.TiCloudStorageRecordingTask
+import com.tange.ai.tirtc.TiCloudStorageReplay
+import com.tange.ai.tirtc.TiCloudStorageSnapshotFile
+import com.tange.ai.tirtc.TiCloudStorageVideoOutput
+import java.util.concurrent.atomic.AtomicInteger
+
+internal object TiRtcReactNativeCleanup {
+    private const val TAG = "TIRTC_REACT_NATIVE"
+
+    fun release(objects: List<Any>, files: List<Any>) {
+        val pending = AtomicInteger(1)
+        fun retain() {
+            pending.incrementAndGet()
+        }
+        fun finish() {
+            if (pending.decrementAndGet() == 0) {
+                Handler(Looper.getMainLooper()).post { releaseOwners(objects) }
+            }
+        }
+        fun delete(file: Any?) {
+            if (file == null) return
+            retain()
+            val completed: (Int) -> Unit = { code ->
+                if (code != 0) logFailure("media_delete", code)
+                finish()
+            }
+            when (file) {
+                is TiRtcRecordingFile -> file.delete(completed)
+                is TiRtcSnapshotFile -> file.delete(completed)
+                is TiCloudStorageRecordingFile -> file.delete(completed)
+                is TiCloudStorageSnapshotFile -> file.delete(completed)
+                else -> finish()
+            }
+        }
+
+        files.forEach(::delete)
+        objects.forEach { value ->
+            when (value) {
+                is TiRtcRecordingTask -> {
+                    retain()
+                    value.stop { result ->
+                        delete(result.file)
+                        finish()
+                    }
+                }
+                is TiCloudStorageRecordingTask -> {
+                    retain()
+                    value.stop { result ->
+                        delete(result.file)
+                        finish()
+                    }
+                }
+                is CloudStorageExportBridge -> {
+                    retain()
+                    value.invalidate { result ->
+                        delete(result?.file)
+                        finish()
+                    }
+                }
+            }
+        }
+        finish()
+    }
+
+    private fun releaseOwners(objects: List<Any>) {
+        objects.filterIsInstance<TiCloudStorageAudioOutput>().forEach { output ->
+            logFailure("ti-cloud-storage-audio-detach", output.detach())
+            logFailure("ti-cloud-storage-audio-dispose", output.dispose())
+        }
+        objects.filterIsInstance<TiCloudStorageVideoOutput>().forEach { output ->
+            logFailure("ti-cloud-storage-video-detach", output.detach())
+            logFailure("ti-cloud-storage-video-view-detach", output.detachView())
+            logFailure("ti-cloud-storage-video-dispose", output.dispose())
+        }
+        objects.filterIsInstance<TiRtcAudioOutput>().forEach { logFailure("audio_output_dispose", it.dispose()) }
+        objects.filterIsInstance<TiRtcVideoOutput>().forEach { logFailure("video_output_dispose", it.dispose()) }
+        objects.filterIsInstance<TiRtcAudioInput>().forEach { logFailure("audio_input_dispose", it.dispose()) }
+        objects.filterIsInstance<TiRtcVideoInput>().forEach { logFailure("video_input_dispose", it.dispose()) }
+        objects.filterIsInstance<TiCloudStorageReplay>().forEach { replay ->
+            logFailure("ti-cloud-storage-replay-stop", replay.stop())
+            logFailure("ti-cloud-storage-replay-dispose", replay.dispose())
+        }
+        objects.filterIsInstance<TiRtcConn>().forEach { conn ->
+            logFailure("conn_disconnect", conn.disconnect())
+            logFailure("conn_dispose", conn.dispose())
+        }
+        objects.filterIsInstance<TiCloudStorage>().forEach { logFailure("ti-cloud-storage-dispose", it.dispose()) }
+        logFailure("ti-cloud-storage-shutdown", TiCloudStorage.shutdown())
+        logFailure("runtime_shutdown", TiRtc.shutdown())
+        TiRtcLogging.i(TAG, "[module_invalidate] native owners released")
+    }
+
+    private fun logFailure(operation: String, code: Int) {
+        if (code != 0 && code != TiRtcReactNativeErrors.OBJECT_RELEASED) {
+            TiRtcLogging.w(TAG, "[module_invalidate] operation=$operation error_code=$code")
+        }
+    }
+}

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

@@ -1,6 +1,5 @@
 package com.tange.ai.tirtc.reactnative
 
-import android.util.Log
 import com.tange.ai.tirtc.TiRtcAudioInput
 import com.tange.ai.tirtc.TiRtcAudioOutput
 import com.tange.ai.tirtc.TiRtcAudioOutputErrorListener
@@ -17,16 +16,47 @@ import com.tange.ai.tirtc.TiRtcVideoOutput
 import com.tange.ai.tirtc.TiRtcVideoOutputErrorListener
 import com.tange.ai.tirtc.TiRtcVideoOutputRenderSizeListener
 import com.tange.ai.tirtc.TiRtcVideoOutputStateListener
+import com.tange.ai.tirtc.TiCloudStorage
+import com.tange.ai.tirtc.TiCloudStorageAudioOutput
+import com.tange.ai.tirtc.TiCloudStorageAudioOutputStateListener
+import com.tange.ai.tirtc.TiCloudStorageOutputErrorListener
+import com.tange.ai.tirtc.TiCloudStorageReplay
+import com.tange.ai.tirtc.TiCloudStorageReplayCompletedListener
+import com.tange.ai.tirtc.TiCloudStorageReplayErrorListener
+import com.tange.ai.tirtc.TiCloudStorageTimeChangedListener
+import com.tange.ai.tirtc.TiCloudStorageVideoOutput
+import com.tange.ai.tirtc.TiCloudStorageVideoOutputStateListener
 
 internal class TiRtcReactNativeEventBinder(
     private val events: TiRtcReactNativeEventSink,
 ) {
+    fun wireCloudStorage(id: Int, cloudStorage: TiCloudStorage) = Unit
+
+    fun wireCloudStorageReplay(id: Int, replay: TiCloudStorageReplay) {
+        replay.onTimeChanged = TiCloudStorageTimeChangedListener { events.tiCloudStorageReplayTimeChanged(id, it) }
+        replay.onCompleted = TiCloudStorageReplayCompletedListener { events.tiCloudStorageReplayCompleted(id) }
+        replay.onError = TiCloudStorageReplayErrorListener { events.tiCloudStorageReplayError(id, it) }
+    }
+
+    fun wireCloudStorageAudioOutput(id: Int, output: TiCloudStorageAudioOutput) {
+        output.onStateChanged = TiCloudStorageAudioOutputStateListener {
+            events.audioOutputStateChanged(id, it.name.lowercase())
+        }
+        output.onError = TiCloudStorageOutputErrorListener { events.audioOutputError(id, it) }
+    }
+
+    fun wireCloudStorageVideoOutput(id: Int, output: TiCloudStorageVideoOutput) {
+        output.onStateChanged = TiCloudStorageVideoOutputStateListener {
+            events.videoOutputStateChanged(id, it.name.lowercase())
+        }
+        output.onError = TiCloudStorageOutputErrorListener { events.videoOutputError(id, it) }
+    }
+
     fun wireConn(
         id: Int,
         conn: TiRtcConn,
     ) {
         conn.onStateChanged = TiRtcConnStateListener { state, errorCode ->
-            Log.i(TAG, "connStateChanged objectId=$id state=${state.name.lowercase()} code=$errorCode")
             events.connStateChanged(id, state.name.lowercase(), errorCode)
         }
         conn.onCommand = TiRtcConnCommandListener { command, data ->
@@ -69,7 +99,6 @@ internal class TiRtcReactNativeEventBinder(
         input: TiRtcAudioInput,
     ) {
         input.onStateChanged = TiRtcInputStateListener { state ->
-            Log.i(TAG, "audioInputStateChanged objectId=$id state=${state.name.lowercase()}")
             events.audioInputStateChanged(id, state.name.lowercase())
         }
         input.onError = TiRtcInputErrorListener { code, message ->
@@ -82,7 +111,6 @@ internal class TiRtcReactNativeEventBinder(
         input: TiRtcVideoInput,
     ) {
         input.onStateChanged = TiRtcInputStateListener { state ->
-            Log.i(TAG, "videoInputStateChanged objectId=$id state=${state.name.lowercase()}")
             events.videoInputStateChanged(id, state.name.lowercase())
         }
         input.onActualConfigChanged = TiRtcVideoInputActualConfigListener { size, fps ->
@@ -92,8 +120,4 @@ internal class TiRtcReactNativeEventBinder(
             events.videoInputError(id, code, message)
         }
     }
-
-    private companion object {
-        const val TAG = "TiRtcReactNative"
-    }
 }

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

@@ -44,6 +44,22 @@ internal class TiRtcReactNativeEventSink(
         })
     }
 
+    fun tiCloudStorageReplayTimeChanged(objectId: Int, timestampMs: Long) {
+        emit(base("tiCloudStorageReplayTimeChanged", objectId).apply {
+            putDouble("timestampMs", timestampMs.toDouble())
+        })
+    }
+
+    fun tiCloudStorageReplayCompleted(objectId: Int) {
+        emit(base("tiCloudStorageReplayCompleted", objectId))
+    }
+
+    fun tiCloudStorageReplayError(objectId: Int, code: Int) {
+        emit(base("tiCloudStorageReplayError", objectId).apply {
+            putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        })
+    }
+
     fun audioOutputStateChanged(
         objectId: Int,
         state: String,

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

@@ -2,6 +2,68 @@ package com.tange.ai.tirtc.reactnative
 
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
+import com.tange.ai.tirtc.TiCloudStorageRecordingRange
+import com.tange.ai.tirtc.TiCloudStorageRecordingDay
+
+internal fun recordingStartResult(code: Int, taskId: Int?): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        if (taskId == null) putNull("taskId") else putInt("taskId", taskId)
+    }
+
+internal fun tiCloudStorageRecordingsResult(code: Int, ranges: List<TiCloudStorageRecordingRange>): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", code)
+        putArray("recordings", Arguments.createArray().apply {
+            ranges.forEach { range ->
+                pushMap(Arguments.createMap().apply {
+                    putDouble("startTimeMs", range.startTimeMs.toDouble())
+                    putDouble("endTimeMs", range.endTimeMs.toDouble())
+                })
+            }
+        })
+    }
+
+internal fun tiCloudStorageRecordingDaysResult(code: Int, days: List<TiCloudStorageRecordingDay>): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", code)
+        putArray("days", Arguments.createArray().apply {
+            days.forEach { day ->
+                pushMap(Arguments.createMap().apply {
+                    putString("date", day.date)
+                    putBoolean("hasRecording", day.hasRecording)
+                })
+            }
+        })
+    }
+
+internal fun tiCloudStorageReplayInfoResult(code: Int, speed: Int, currentTimeMs: Long?): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", code)
+        putInt("speed", speed)
+        if (currentTimeMs == null) putNull("currentTimeMs") else putDouble("currentTimeMs", currentTimeMs.toDouble())
+    }
+
+internal fun mp4Result(code: Int, fileId: Int?, filePath: String?, durationMs: Long?): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        if (fileId == null) putNull("fileId") else putInt("fileId", fileId)
+        if (filePath == null) putNull("filePath") else putString("filePath", filePath)
+        if (durationMs == null) putNull("durationMs") else putDouble("durationMs", durationMs.toDouble())
+    }
+
+internal fun mediaSnapshotResult(code: Int, fileId: Int?, filePath: String?): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        if (fileId == null) putNull("fileId") else putInt("fileId", fileId)
+        if (filePath == null) putNull("filePath") else putString("filePath", filePath)
+    }
+
+internal fun galleryResult(code: Int, uri: String?): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        if (uri == null) putNull("uri") else putString("uri", uri)
+    }
 
 internal fun createResult(
     code: Int,

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

@@ -2,7 +2,6 @@ package com.tange.ai.tirtc.reactnative
 
 import android.os.Handler
 import android.os.Looper
-import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableArray
@@ -11,18 +10,21 @@ import com.tange.ai.tirtc.TiRtcLogging
 import java.util.concurrent.atomic.AtomicBoolean
 
 private const val LOG_UPLOAD_TIMEOUT_MS = 30_000L
+private const val TAG = "TiRtcReactNative"
 
 internal fun uploadLogsToPromise(
     promise: Promise,
-    tag: String,
 ) {
-    Log.i(tag, "uploadLogs start")
     val settled = AtomicBoolean(false)
     val timeoutHandler = Handler(Looper.getMainLooper())
     val timeout =
         Runnable {
             if (settled.compareAndSet(false, true)) {
-                Log.w(tag, "uploadLogs timeout")
+                TiRtcLogging.e(
+                    TAG,
+                    "[react_native_log_upload] failed: native upload did not settle the Promise before timeout; " +
+                        "error_code=1001 reason=promise_timeout",
+                )
                 promise.resolve(
                     Arguments.createMap().apply {
                         putInt("code", TiRtcReactNativeErrors.PLATFORM_INTERNAL)
@@ -37,7 +39,6 @@ internal fun uploadLogsToPromise(
             return@upload
         }
         timeoutHandler.removeCallbacks(timeout)
-        Log.i(tag, "uploadLogs completed code=$code logIdPresent=${!logId.isNullOrEmpty()}")
         promise.resolve(
             Arguments.createMap().apply {
                 putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
@@ -50,7 +51,6 @@ internal fun uploadLogsToPromise(
             return
         }
         timeoutHandler.removeCallbacks(timeout)
-        Log.w(tag, "uploadLogs failed_to_start code=$startCode")
         promise.resolve(
             Arguments.createMap().apply {
                 putInt("code", TiRtcReactNativeErrors.normalizeAndroid(startCode))

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

@@ -5,6 +5,12 @@ import com.tange.ai.tirtc.TiRtcAudioOutput
 import com.tange.ai.tirtc.TiRtcConn
 import com.tange.ai.tirtc.TiRtcVideoInput
 import com.tange.ai.tirtc.TiRtcVideoOutput
+import com.tange.ai.tirtc.TiRtcRecordingTask
+import com.tange.ai.tirtc.TiCloudStorage
+import com.tange.ai.tirtc.TiCloudStorageAudioOutput
+import com.tange.ai.tirtc.TiCloudStorageRecordingTask
+import com.tange.ai.tirtc.TiCloudStorageReplay
+import com.tange.ai.tirtc.TiCloudStorageVideoOutput
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicInteger
 
@@ -32,6 +38,13 @@ internal object TiRtcReactNativeRegistry {
         events = eventSink
     }
 
+    fun drain(eventSink: TiRtcReactNativeEventSink): List<Any> {
+        val values = entries.values.map(Entry::value)
+        entries.clear()
+        if (events === eventSink) events = null
+        return values
+    }
+
     fun release(id: Int) {
         entries.remove(id)
     }
@@ -48,6 +61,20 @@ internal object TiRtcReactNativeRegistry {
 
     fun videoInput(id: Int): TiRtcVideoInput? = entries[id]?.value as? TiRtcVideoInput
 
+    fun recordingTask(id: Int): TiRtcRecordingTask? = entries[id]?.value as? TiRtcRecordingTask
+
+    fun cloudStorage(id: Int): TiCloudStorage? = entries[id]?.value as? TiCloudStorage
+
+    fun tiCloudStorageReplay(id: Int): TiCloudStorageReplay? = entries[id]?.value as? TiCloudStorageReplay
+
+    fun tiCloudStorageRecordingTask(id: Int): TiCloudStorageRecordingTask? = entries[id]?.value as? TiCloudStorageRecordingTask
+
+    fun tiCloudStorageExportTask(id: Int): CloudStorageExportBridge? = entries[id]?.value as? CloudStorageExportBridge
+
+    fun tiCloudStorageAudioOutput(id: Int): TiCloudStorageAudioOutput? = entries[id]?.value as? TiCloudStorageAudioOutput
+
+    fun tiCloudStorageVideoOutput(id: Int): TiCloudStorageVideoOutput? = entries[id]?.value as? TiCloudStorageVideoOutput
+
     fun reportVideoOutputError(
         id: Int,
         code: Int,

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

@@ -0,0 +1,64 @@
+package com.tange.ai.tirtc.reactnative
+
+import com.facebook.react.bridge.Promise
+import com.tange.ai.tirtc.TiCloudStorageExportTask
+import com.tange.ai.tirtc.TiCloudStorageRecordingResult
+
+internal class CloudStorageExportBridge(
+    private val resolve: (Promise, TiCloudStorageRecordingResult) -> Unit,
+) {
+    @Volatile var task: TiCloudStorageExportTask? = null
+    @Volatile var onDrained: (() -> Unit)? = null
+    private var result: TiCloudStorageRecordingResult? = null
+    private val waiters = mutableListOf<Promise>()
+    private var invalidated = false
+    private var invalidationCompletion: ((TiCloudStorageRecordingResult?) -> Unit)? = null
+
+    fun complete(value: TiCloudStorageRecordingResult) {
+        val completed = synchronized(this) {
+            if (result != null) return
+            result = value
+            val pending = if (invalidated) emptyList() else waiters.toList()
+            waiters.clear()
+            pending to invalidationCompletion.also { invalidationCompletion = null }
+        }
+        completed.first.forEach { resolve(it, value) }
+        if (completed.first.isNotEmpty()) onDrained?.invoke()
+        completed.second?.invoke(value)
+    }
+
+    fun await(promise: Promise) {
+        val completed = synchronized(this) {
+            result?.also { return@synchronized it } ?: run {
+                waiters += promise
+                null
+            }
+        }
+        if (completed != null) {
+            resolve(promise, completed)
+            onDrained?.invoke()
+        }
+    }
+
+    fun invalidate(onTerminal: (TiCloudStorageRecordingResult?) -> Unit) {
+        val completed = synchronized(this) {
+            invalidated = true
+            waiters.clear()
+            result?.also { return@synchronized it } ?: run {
+                invalidationCompletion = onTerminal
+                null
+            }
+        }
+        if (completed != null) {
+            onTerminal(completed)
+            return
+        }
+        val code = task?.stop() ?: TiRtcReactNativeErrors.OBJECT_RELEASED
+        if (code != 0) {
+            synchronized(this) {
+                invalidationCompletion = null
+            }
+            onTerminal(null)
+        }
+    }
+}

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

@@ -22,7 +22,7 @@ class TiRtcVideoOutputViewManager :
 
     override fun onDropViewInstance(view: FrameLayout) {
         (view.getTag(ATTACHED_ID_TAG) as? Int)?.let { id ->
-            TiRtcReactNativeRegistry.videoOutput(id)?.detachView()
+            detachView(id)
         }
         super.onDropViewInstance(view)
     }
@@ -63,7 +63,7 @@ class TiRtcVideoOutputViewManager :
         val attachedId = view.getTag(ATTACHED_ID_TAG) as? Int
         val attachedGeneration = view.getTag(ATTACHED_GENERATION_TAG) as? Int
         if (attachedId != null && (attachedId != nativeObjectId || attachedGeneration != generation)) {
-            TiRtcReactNativeRegistry.videoOutput(attachedId)?.detachView()
+            detachView(attachedId)
             view.setTag(ATTACHED_ID_TAG, null)
             view.setTag(ATTACHED_GENERATION_TAG, null)
         }
@@ -86,7 +86,22 @@ class TiRtcVideoOutputViewManager :
             }
             view.setTag(ATTACHED_ID_TAG, nativeObjectId)
             view.setTag(ATTACHED_GENERATION_TAG, generation)
+            return
         }
+        TiRtcReactNativeRegistry.tiCloudStorageVideoOutput(nativeObjectId)?.let { output ->
+            val code = output.attachView(view)
+            if (TiRtcReactNativeErrors.normalizeAndroid(code) != TiRtcReactNativeErrors.OK) {
+                TiRtcReactNativeRegistry.reportVideoOutputError(nativeObjectId, code)
+                return
+            }
+            view.setTag(ATTACHED_ID_TAG, nativeObjectId)
+            view.setTag(ATTACHED_GENERATION_TAG, generation)
+        }
+    }
+
+    private fun detachView(id: Int) {
+        TiRtcReactNativeRegistry.videoOutput(id)?.detachView()
+            ?: TiRtcReactNativeRegistry.tiCloudStorageVideoOutput(id)?.detachView()
     }
 
     private fun resizeModeForView(view: FrameLayout): TiRtcVideoViewResizeMode =

package/ios/TiRtcReactNative+Conn.mm

@@ -1,6 +1,39 @@
 #import "TiRtcReactNative+Private.h"
 #import "TiRtcReactNativeErrors.h"
 #import "TiRtcReactNativeMaps.h"
+#import <Photos/Photos.h>
+
+static NSString* TiRtcReactNativeGalleryFileName(NSString* fileName, BOOL video) {
+  NSString* extension = video ? @".mp4" : @".jpg";
+  if (fileName == nil) {
+    return [NSString stringWithFormat:@"%lld%@",
+                                      (long long)(NSDate.date.timeIntervalSince1970 * 1000),
+                                      extension];
+  }
+  unichar nul = 0;
+  NSString* nulString = [NSString stringWithCharacters:&nul length:1];
+  if (fileName.length == 0 ||
+      [[fileName stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceAndNewlineCharacterSet]
+          length] == 0 ||
+      [fileName isEqualToString:@"."] || [fileName isEqualToString:@".."] ||
+      [fileName containsString:@"/"] || [fileName containsString:@"\\"] ||
+      [fileName containsString:nulString]) {
+    return nil;
+  }
+  NSString* stem = nil;
+  NSString* normalized = nil;
+  if ([fileName.lowercaseString hasSuffix:extension]) {
+    stem = [fileName substringToIndex:fileName.length - extension.length];
+    normalized = fileName;
+  } else if ([fileName containsString:@"."]) {
+    return nil;
+  } else {
+    stem = fileName;
+    normalized = [fileName stringByAppendingString:extension];
+  }
+  NSUInteger stemBytes = [stem lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+  return stemBytes >= 1 && stemBytes <= 200 ? normalized : nil;
+}
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
@@ -96,6 +129,138 @@
                   }];
 }
 
+- (NSDictionary*)connStartRecording:(double)objectId
+                            options:(JS::NativeTiRtc::NativeRecordingOptions&)options {
+  TiRtcConn* conn = [self conn:objectId];
+  if (conn == nil) {
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull};
+  }
+  NSNumber* audioStreamId =
+      options.audioStreamId().has_value() ? @(options.audioStreamId().value()) : nil;
+  TiRtcRecordingTaskStartResult* result =
+      [conn startRecordingWithVideoStreamId:(int32_t)options.videoStreamId()
+                              audioStreamId:audioStreamId];
+  if (result.code != 0 || result.task == nil) {
+    return @{@"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)), @"taskId" : (id)kCFNull};
+  }
+  NSInteger taskId = [[self registry] addObject:result.task];
+  return @{@"code" : @(TiRtcReactNativeErrorOK), @"taskId" : @(taskId)};
+}
+
+- (void)recordingTaskStop:(double)objectId
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+  TiRtcRecordingTask* task = [[self registry] objectForId:(NSInteger)objectId];
+  if (![task isKindOfClass:[TiRtcRecordingTask class]]) {
+    resolve(@{
+      @"code" : @(TiRtcReactNativeErrorObjectReleased),
+      @"fileId" : (id)kCFNull,
+      @"filePath" : (id)kCFNull,
+      @"durationMs" : (id)kCFNull
+    });
+    return;
+  }
+  [task stopWithCompletion:^(TiRtcRecordingResult* result) {
+    [[self registry] releaseObject:(NSInteger)objectId];
+    NSInteger fileId = result.file == nil ? 0 : [[self registry] addTransientObject:result.file];
+    resolve(@{
+      @"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)),
+      @"fileId" : fileId == 0 ? (id)kCFNull : @(fileId),
+      @"filePath" : result.file.path ?: (id)kCFNull,
+      @"durationMs" : result.file != nil ? @(result.file.durationMs) : (id)kCFNull
+    });
+  }];
+}
+
+- (void)mediaFileMoveToGallery:(double)objectId
+                      fileName:(NSString*)fileName
+                       resolve:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject {
+  id file = [[self registry] transientObjectForId:(NSInteger)objectId];
+  if (![file isKindOfClass:[TiRtcRecordingFile class]] &&
+      ![file isKindOfClass:[TiRtcSnapshotFile class]] &&
+      ![file isKindOfClass:[TiCloudStorageRecordingFile class]] &&
+      ![file isKindOfClass:[TiCloudStorageSnapshotFile class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"uri" : (id)kCFNull});
+    return;
+  }
+  NSString* path = [file path];
+  BOOL video = [file isKindOfClass:[TiRtcRecordingFile class]] ||
+               [file isKindOfClass:[TiCloudStorageRecordingFile class]];
+  NSString* normalizedName = TiRtcReactNativeGalleryFileName(fileName, video);
+  if (normalizedName == nil) {
+    resolve(@{@"code" : @6000, @"uri" : (id)kCFNull});
+    return;
+  }
+  if (![[NSFileManager defaultManager] isReadableFileAtPath:path]) {
+    resolve(@{@"code" : @6045, @"uri" : (id)kCFNull});
+    return;
+  }
+  PHAuthorizationStatus status =
+      [PHPhotoLibrary authorizationStatusForAccessLevel:PHAccessLevelAddOnly];
+  if (status != PHAuthorizationStatusAuthorized && status != PHAuthorizationStatusLimited) {
+    resolve(@{@"code" : @6024, @"uri" : (id)kCFNull});
+    return;
+  }
+  __block NSString* localIdentifier = nil;
+  [[PHPhotoLibrary sharedPhotoLibrary]
+      performChanges:^{
+        PHAssetCreationRequest* request = [PHAssetCreationRequest creationRequestForAsset];
+        PHAssetResourceCreationOptions* options = [[PHAssetResourceCreationOptions alloc] init];
+        options.originalFilename = normalizedName;
+        [request addResourceWithType:video ? PHAssetResourceTypeVideo : PHAssetResourceTypePhoto
+                             fileURL:[NSURL fileURLWithPath:path]
+                              options:options];
+        localIdentifier = request.placeholderForCreatedAsset.localIdentifier;
+      }
+      completionHandler:^(BOOL success, __unused NSError* error) {
+        if (!success || localIdentifier.length == 0) {
+          resolve(@{@"code" : @6046, @"uri" : (id)kCFNull});
+          return;
+        }
+        void (^deleted)(int32_t) = ^(int32_t code) {
+          if (code == 0) {
+            [[self registry] releaseTransientObject:(NSInteger)objectId];
+            resolve(@{@"code" : @0,
+                      @"uri" : [@"ph://" stringByAppendingString:localIdentifier]});
+            return;
+          }
+          PHFetchResult<PHAsset*>* assets =
+              [PHAsset fetchAssetsWithLocalIdentifiers:@[ localIdentifier ] options:nil];
+          [[PHPhotoLibrary sharedPhotoLibrary]
+              performChanges:^{ [PHAssetChangeRequest deleteAssets:assets]; }
+              completionHandler:^(__unused BOOL rolledBack, __unused NSError* rollbackError) {
+                resolve(@{@"code" : @(TiRtcReactNativeNormalizeDarwin(code)),
+                          @"uri" : (id)kCFNull});
+              }];
+        };
+        [file deleteWithCompletion:deleted];
+      }];
+}
+
+- (void)mediaFileDelete:(double)objectId
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+  id file = [[self registry] transientObjectForId:(NSInteger)objectId];
+  if (![file isKindOfClass:[TiRtcRecordingFile class]] &&
+      ![file isKindOfClass:[TiRtcSnapshotFile class]] &&
+      ![file isKindOfClass:[TiCloudStorageRecordingFile class]] &&
+      ![file isKindOfClass:[TiCloudStorageSnapshotFile class]]) {
+    resolve(@(TiRtcReactNativeErrorObjectReleased));
+    return;
+  }
+  [file deleteWithCompletion:^(int32_t code) {
+    if (code == 0) {
+      [[self registry] releaseTransientObject:(NSInteger)objectId];
+    }
+    resolve(@(TiRtcReactNativeNormalizeDarwin(code)));
+  }];
+}
+
+- (void)mediaFileRelease:(double)objectId {
+  [[self registry] releaseTransientObject:(NSInteger)objectId];
+}
+
 - (NSDictionary*)connGetMetricsSnapshot:(double)objectId {
   TiRtcConn* conn = [self conn:objectId];
   return conn == nil ? TiRtcReactNativeReleasedSnapshotResult()
@@ -104,8 +269,14 @@
 
 - (NSNumber*)connDispose:(double)objectId {
   TiRtcConn* conn = [self conn:objectId];
-  [conn dispose];
-  return [self releaseRegisteredObject:(NSInteger)objectId object:conn];
+  if (conn == nil) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  NSInteger code = TiRtcReactNativeNormalizeDarwin([conn dispose]);
+  if (code == TiRtcReactNativeErrorOK) {
+    [self releaseRegisteredObject:(NSInteger)objectId object:conn];
+  }
+  return @(code);
 }
 
 @end