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

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.TiStore
+import com.tange.ai.tirtc.TiStoreAudioOutput
+import com.tange.ai.tirtc.TiStoreRecordingFile
+import com.tange.ai.tirtc.TiStoreRecordingTask
+import com.tange.ai.tirtc.TiStoreReplay
+import com.tange.ai.tirtc.TiStoreSnapshotFile
+import com.tange.ai.tirtc.TiStoreVideoOutput
+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 TiStoreRecordingFile -> file.delete(completed)
+                is TiStoreSnapshotFile -> file.delete(completed)
+                else -> finish()
+            }
+        }
+
+        files.forEach(::delete)
+        objects.forEach { value ->
+            when (value) {
+                is TiRtcRecordingTask -> {
+                    retain()
+                    value.stop { result ->
+                        delete(result.file)
+                        finish()
+                    }
+                }
+                is TiStoreRecordingTask -> {
+                    retain()
+                    value.stop { result ->
+                        delete(result.file)
+                        finish()
+                    }
+                }
+                is StoreExportBridge -> {
+                    retain()
+                    value.invalidate { result ->
+                        delete(result?.file)
+                        finish()
+                    }
+                }
+            }
+        }
+        finish()
+    }
+
+    private fun releaseOwners(objects: List<Any>) {
+        objects.filterIsInstance<TiStoreAudioOutput>().forEach { output ->
+            logFailure("store_audio_detach", output.detach())
+            logFailure("store_audio_dispose", output.dispose())
+        }
+        objects.filterIsInstance<TiStoreVideoOutput>().forEach { output ->
+            logFailure("store_video_detach", output.detach())
+            logFailure("store_video_view_detach", output.detachView())
+            logFailure("store_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<TiStoreReplay>().forEach { replay ->
+            logFailure("store_replay_stop", replay.stop())
+            logFailure("store_replay_dispose", replay.dispose())
+        }
+        objects.filterIsInstance<TiRtcConn>().forEach { conn ->
+            logFailure("conn_disconnect", conn.disconnect())
+            logFailure("conn_dispose", conn.dispose())
+        }
+        objects.filterIsInstance<TiStore>().forEach { logFailure("store_dispose", it.dispose()) }
+        logFailure("store_shutdown", TiStore.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,50 @@ 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.TiStore
+import com.tange.ai.tirtc.TiStoreAudioOutput
+import com.tange.ai.tirtc.TiStoreAudioOutputStateListener
+import com.tange.ai.tirtc.TiStoreOutputErrorListener
+import com.tange.ai.tirtc.TiStoreReplay
+import com.tange.ai.tirtc.TiStoreReplayCompletedListener
+import com.tange.ai.tirtc.TiStoreReplayErrorListener
+import com.tange.ai.tirtc.TiStoreTimeChangedListener
+import com.tange.ai.tirtc.TiStoreTokenExpiredListener
+import com.tange.ai.tirtc.TiStoreVideoOutput
+import com.tange.ai.tirtc.TiStoreVideoOutputStateListener
 
 internal class TiRtcReactNativeEventBinder(
     private val events: TiRtcReactNativeEventSink,
 ) {
+    fun wireStore(id: Int, store: TiStore) {
+        store.onTokenExpired = TiStoreTokenExpiredListener { events.storeTokenExpired(id) }
+    }
+
+    fun wireStoreReplay(id: Int, replay: TiStoreReplay) {
+        replay.onTimeChanged = TiStoreTimeChangedListener { events.storeReplayTimeChanged(id, it) }
+        replay.onCompleted = TiStoreReplayCompletedListener { events.storeReplayCompleted(id) }
+        replay.onError = TiStoreReplayErrorListener { events.storeReplayError(id, it) }
+    }
+
+    fun wireStoreAudioOutput(id: Int, output: TiStoreAudioOutput) {
+        output.onStateChanged = TiStoreAudioOutputStateListener {
+            events.audioOutputStateChanged(id, it.name.lowercase())
+        }
+        output.onError = TiStoreOutputErrorListener { events.audioOutputError(id, it) }
+    }
+
+    fun wireStoreVideoOutput(id: Int, output: TiStoreVideoOutput) {
+        output.onStateChanged = TiStoreVideoOutputStateListener {
+            events.videoOutputStateChanged(id, it.name.lowercase())
+        }
+        output.onError = TiStoreOutputErrorListener { 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 +102,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 +114,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 +123,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,26 @@ internal class TiRtcReactNativeEventSink(
         })
     }
 
+    fun storeTokenExpired(objectId: Int) {
+        emit(base("storeTokenExpired", objectId))
+    }
+
+    fun storeReplayTimeChanged(objectId: Int, timestampMs: Long) {
+        emit(base("storeReplayTimeChanged", objectId).apply {
+            putDouble("timestampMs", timestampMs.toDouble())
+        })
+    }
+
+    fun storeReplayCompleted(objectId: Int) {
+        emit(base("storeReplayCompleted", objectId))
+    }
+
+    fun storeReplayError(objectId: Int, code: Int) {
+        emit(base("storeReplayError", 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.TiStoreRecordingRange
+import com.tange.ai.tirtc.TiStoreRecordingDay
+
+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 storeRecordingsResult(code: Int, ranges: List<TiStoreRecordingRange>): 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 storeRecordingDaysResult(code: Int, days: List<TiStoreRecordingDay>): 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 storeReplayInfoResult(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.TiStore
+import com.tange.ai.tirtc.TiStoreAudioOutput
+import com.tange.ai.tirtc.TiStoreRecordingTask
+import com.tange.ai.tirtc.TiStoreReplay
+import com.tange.ai.tirtc.TiStoreVideoOutput
 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 store(id: Int): TiStore? = entries[id]?.value as? TiStore
+
+    fun storeReplay(id: Int): TiStoreReplay? = entries[id]?.value as? TiStoreReplay
+
+    fun storeRecordingTask(id: Int): TiStoreRecordingTask? = entries[id]?.value as? TiStoreRecordingTask
+
+    fun storeExportTask(id: Int): StoreExportBridge? = entries[id]?.value as? StoreExportBridge
+
+    fun storeAudioOutput(id: Int): TiStoreAudioOutput? = entries[id]?.value as? TiStoreAudioOutput
+
+    fun storeVideoOutput(id: Int): TiStoreVideoOutput? = entries[id]?.value as? TiStoreVideoOutput
+
     fun reportVideoOutputError(
         id: Int,
         code: Int,

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

@@ -0,0 +1,64 @@
+package com.tange.ai.tirtc.reactnative
+
+import com.facebook.react.bridge.Promise
+import com.tange.ai.tirtc.TiStoreExportTask
+import com.tange.ai.tirtc.TiStoreRecordingResult
+
+internal class StoreExportBridge(
+    private val resolve: (Promise, TiStoreRecordingResult) -> Unit,
+) {
+    @Volatile var task: TiStoreExportTask? = null
+    @Volatile var onDrained: (() -> Unit)? = null
+    private var result: TiStoreRecordingResult? = null
+    private val waiters = mutableListOf<Promise>()
+    private var invalidated = false
+    private var invalidationCompletion: ((TiStoreRecordingResult?) -> Unit)? = null
+
+    fun complete(value: TiStoreRecordingResult) {
+        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: (TiStoreRecordingResult?) -> 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.storeVideoOutput(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.storeVideoOutput(id)?.detachView()
     }
 
     private fun resizeModeForView(view: FrameLayout): TiRtcVideoViewResizeMode =