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

package/README.md

@@ -1,16 +1,16 @@
 # TiRTC React Native SDK
 
-`tirtc-react-native` is the TiRTC and TiStore React Native New Architecture package for Android and iOS.
+`tirtc-react-native` is the TiRTC and Ti Cloud Storage React Native New Architecture package for Android and iOS.
 
 ```sh
 npm install tirtc-react-native
 ```
 
-The package ships ESM JavaScript, TypeScript declarations, Codegen specs, Android native wrapper code and iOS native wrapper code. RTC and Store use the same native Runtime delivery but keep separate initialization and resource lifecycles. The package requires React Native `>=0.80.0`, Android `com.tange.ai:tirtc:2.4.0-alpha.3`, and iOS `TiRTC` `2.4.0-alpha.3` with iOS minimum `15.1`.
+The package ships ESM JavaScript, TypeScript declarations, Codegen specs, Android native wrapper code and iOS native wrapper code. RTC and CloudStorage use the same native Runtime delivery but keep separate initialization and resource lifecycles. The package requires React Native `>=0.80.0`, Android `com.tange.ai:tirtc:2.4.0`, and iOS `TiRTC` `2.4.0` with iOS minimum `15.1`.
 
 The iOS package supports arm64 devices and Apple Silicon iOS Simulator. Simulator validation covers build, launch, connection, downlink audio, and downlink video; capture and iOS behavioral qualification remain real-device gates.
 
-Version `2.4.0-alpha.3` is an alpha React Native release aligned with the TiRTC 2.4.0-alpha.3 Android and Darwin SDKs.
+Version `2.4.0` is the stable React Native release aligned with the TiRTC 2.4.0 Android and Darwin SDKs.
 
 ## Imports
 
@@ -121,7 +121,7 @@ export function LocalPreview() {
 
 ## Saving Temporary Media
 
-RTC recordings, RTC snapshots, Store recordings, and Store snapshots return temporary cache file objects. Publish one to the Android or iOS system media library with an optional final filename:
+RTC recordings, RTC snapshots, CloudStorage recordings, and CloudStorage snapshots return temporary cache file objects. Publish one to the Android or iOS system media library with an optional final filename:
 
 ```ts
 const result = await file.moveToGallery(
@@ -139,7 +139,7 @@ Constructors create native owner identities, so outputs and inputs can attach to
 
 ## Release
 
-Version `2.4.0-alpha.3` is the current React Native package for TiRTC client media output and talkback. It supports React Native New Architecture apps on Android and iOS and pins Android `com.tange.ai:tirtc:2.4.0-alpha.3` and iOS `TiRTC` `2.4.0-alpha.3`.
+Version `2.4.0` is the current stable React Native package for TiRTC and Ti Cloud Storage. It supports React Native New Architecture apps on Android and iOS and pins Android `com.tange.ai:tirtc:2.4.0` and iOS `TiRTC` `2.4.0`.
 
 ## License
 
@@ -159,7 +159,7 @@ The external application sample is published under `react-native/` in
 `tirtc-api-samples`. The owner-local projection and recovery entry is:
 
 ```sh
-./scripts/publish_api_samples.sh --version 2.4.0-alpha.3
+./scripts/publish_api_samples.sh --version 2.4.0
 ```
 
 Use `--no-push` for a complete local projection/build rehearsal without writing

package/TiRtcReactNative.podspec

@@ -13,7 +13,7 @@ Pod::Spec.new do |s|
   s.source = { :git => 'https://gitlab.tange-ai.com/tirtc-nexus/tirtc.git', :tag => s.version.to_s }
   s.source_files = 'ios/**/*.{h,m,mm,swift}'
   s.dependency 'React-Core'
-  s.dependency 'TiRTC', '2.4.0-alpha.3'
+  s.dependency 'TiRTC', '2.4.0'
 
   if respond_to?(:install_modules_dependencies, true)
     install_modules_dependencies(s)

package/android/build.gradle

@@ -29,7 +29,7 @@ repositories {
 
 dependencies {
   implementation "com.facebook.react:react-android"
-  implementation "com.tange.ai:tirtc:${safeExtGet("tirtcAndroidVersion", "2.4.0-alpha.3")}"
+  implementation "com.tange.ai:tirtc:${safeExtGet("tirtcAndroidVersion", "2.4.0")}"
 }
 
 def safeExtGet(prop, fallback) {

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

@@ -5,6 +5,8 @@ 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
@@ -23,16 +25,17 @@ 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.TiStore
-import com.tange.ai.tirtc.TiStoreAudioOutput
-import com.tange.ai.tirtc.TiStoreExportRequest
-import com.tange.ai.tirtc.TiStoreRecordingFile
-import com.tange.ai.tirtc.TiStoreRecordingResult
-import com.tange.ai.tirtc.TiStoreReplaySpeed
-import com.tange.ai.tirtc.TiStoreSnapshotFile
-import com.tange.ai.tirtc.TiStoreVideoOutput
+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
@@ -56,6 +59,7 @@ class TiRtcModule(
     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)
@@ -117,8 +121,8 @@ class TiRtcModule(
     }
 
     @ReactMethod
-    override fun storeInitialize(options: ReadableMap, promise: Promise) {
-        val code = TiStore.init(
+    override fun tiCloudStorageInitialize(options: ReadableMap, promise: Promise) {
+        val code = TiCloudStorage.init(
             reactContext,
             options.getString("appId") ?: "",
             options.getString("endpoint") ?: "",
@@ -127,74 +131,74 @@ class TiRtcModule(
         promise.resolve(code.toDouble())
     }
 
-    override fun storeShutdown(): Double = TiStore.shutdown().toDouble()
+    override fun tiCloudStorageShutdown(): Double = TiCloudStorage.shutdown().toDouble()
 
-    override fun storeCreate(token: String): WritableMap =
+    override fun tiCloudStorageCreate(token: String): WritableMap =
         registerReactNativeObject(
             registry,
-            factory = { TiStore(token) },
-            onRegistered = { entry, value -> eventBinder.wireStore(entry.id, value as TiStore) },
+            factory = { TiCloudStorage(token) },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorage(entry.id, value as TiCloudStorage) },
         )
 
-    override fun storeUpdateToken(id: Double, token: String): Double =
-        registry.store(id.toInt())?.updateToken(token).normalized()
+    override fun tiCloudStorageUpdateToken(id: Double, token: String): Double =
+        registry.cloudStorage(id.toInt())?.updateToken(token).normalized()
 
     @ReactMethod
-    override fun storeListRecordings(id: Double, startTimeMs: Double, endTimeMs: Double, promise: Promise) {
-        val store = registry.store(id.toInt())
-        if (store == null) {
-            promise.resolve(storeRecordingsResult(TiRtcReactNativeErrors.OBJECT_RELEASED, emptyList()))
+    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
         }
-        store.listRecordings(startTimeMs.toLong(), endTimeMs.toLong()) { result ->
+        cloudStorage.listRecordings(startTimeMs.toLong(), endTimeMs.toLong()) { result ->
             reactContext.runOnJSQueueThread {
-                promise.resolve(storeRecordingsResult(result.code, result.recordings))
+                promise.resolve(tiCloudStorageRecordingsResult(result.code, result.recordings))
             }
         }
     }
 
     @ReactMethod
-    override fun storeListRecordingDays(
+    override fun tiCloudStorageListRecordingDays(
         id: Double,
         startDate: String,
         endDate: String,
         timeZoneId: String,
         promise: Promise,
     ) {
-        val store = registry.store(id.toInt())
-        if (store == null) {
-            promise.resolve(storeRecordingDaysResult(TiRtcReactNativeErrors.OBJECT_RELEASED, emptyList()))
+        val cloudStorage = registry.cloudStorage(id.toInt())
+        if (cloudStorage == null) {
+            promise.resolve(tiCloudStorageRecordingDaysResult(TiRtcReactNativeErrors.OBJECT_RELEASED, emptyList()))
             return
         }
-        store.listRecordingDays(startDate, endDate, timeZoneId) { result ->
+        cloudStorage.listRecordingDays(startDate, endDate, timeZoneId) { result ->
             reactContext.runOnJSQueueThread {
-                promise.resolve(storeRecordingDaysResult(result.code, result.days))
+                promise.resolve(tiCloudStorageRecordingDaysResult(result.code, result.days))
             }
         }
     }
 
-    override fun storeCreateReplay(id: Double): WritableMap {
-        val store = registry.store(id.toInt())
+    override fun tiCloudStorageCreateReplay(id: Double): WritableMap {
+        val cloudStorage = registry.cloudStorage(id.toInt())
             ?: return createResult(TiRtcReactNativeErrors.OBJECT_RELEASED, 0, 0)
         return registerReactNativeObject(
             registry,
-            factory = { store.createReplay() },
-            onRegistered = { entry, value -> eventBinder.wireStoreReplay(entry.id, value as com.tange.ai.tirtc.TiStoreReplay) },
+            factory = { cloudStorage.createReplay() },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorageReplay(entry.id, value as com.tange.ai.tirtc.TiCloudStorageReplay) },
         )
     }
 
-    override fun storeExportRecording(
+    override fun tiCloudStorageExportRecording(
         id: Double,
         startTimeMs: Double,
         endTimeMs: Double,
         videoChannelId: Double,
         audioChannelId: Double?,
     ): WritableMap {
-        val store = registry.store(id.toInt())
+        val cloudStorage = registry.cloudStorage(id.toInt())
             ?: return recordingStartResult(TiRtcReactNativeErrors.OBJECT_RELEASED, null)
-        val bridge = StoreExportBridge(::resolveStoreRecording)
-        val started = store.exportRecording(
-            TiStoreExportRequest(
+        val bridge = CloudStorageExportBridge(::resolveCloudStorageRecording)
+        val started = cloudStorage.exportRecording(
+            TiCloudStorageExportRequest(
                 startTimeMs.toLong(),
                 endTimeMs.toLong(),
                 videoChannelId.toInt(),
@@ -209,71 +213,77 @@ class TiRtcModule(
         return recordingStartResult(started.code, entry.id)
     }
 
-    override fun storeExportProgress(id: Double): Double =
-        registry.storeExportTask(id.toInt())?.task?.progress ?: 0.0
+    override fun tiCloudStorageExportProgress(id: Double): Double =
+        registry.tiCloudStorageExportTask(id.toInt())?.task?.progress ?: 0.0
 
     @ReactMethod
-    override fun storeExportResult(id: Double, promise: Promise) {
-        registry.storeExportTask(id.toInt())?.await(promise)
+    override fun tiCloudStorageExportResult(id: Double, promise: Promise) {
+        registry.tiCloudStorageExportTask(id.toInt())?.await(promise)
             ?: promise.resolve(mp4Result(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null, null))
     }
 
-    override fun storeExportStop(id: Double): Double =
-        registry.storeExportTask(id.toInt())?.task?.stop().normalized()
+    override fun tiCloudStorageExportStop(id: Double): Double =
+        registry.tiCloudStorageExportTask(id.toInt())?.task?.stop().normalized()
 
-    override fun storeDispose(id: Double): Double {
+    override fun tiCloudStorageDispose(id: Double): Double {
         val objectId = id.toInt()
-        val code = registry.store(objectId)?.dispose().normalized()
+        val code = registry.cloudStorage(objectId)?.dispose().normalized()
         if (code.toInt() == TiRtcReactNativeErrors.OK) registry.release(objectId)
         return code
     }
 
-    override fun storeReplayGetInfo(id: Double): WritableMap {
-        val replay = registry.storeReplay(id.toInt())
-            ?: return storeReplayInfoResult(TiRtcReactNativeErrors.OBJECT_RELEASED, 0, null)
+    override fun tiCloudStorageReplayGetInfo(id: Double): WritableMap {
+        val replay = registry.tiCloudStorageReplay(id.toInt())
+            ?: return tiCloudStorageReplayInfoResult(TiRtcReactNativeErrors.OBJECT_RELEASED, 0, null)
         val speed = when (replay.speed) {
-            TiStoreReplaySpeed.X1 -> 0
-            TiStoreReplaySpeed.X2 -> 1
-            TiStoreReplaySpeed.X4 -> 2
-            TiStoreReplaySpeed.X8 -> 3
+            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 storeReplayInfoResult(0, speed, replay.currentTimeMs)
+        return tiCloudStorageReplayInfoResult(0, speed, replay.currentTimeMs)
     }
 
-    override fun storeReplayPlay(
+    override fun tiCloudStorageReplayPlay(
         id: Double,
         startTimeMs: Double,
         endTimeMs: Double,
         initialTimeMs: Double?,
     ): Double {
-        val replay = registry.storeReplay(id.toInt()) ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
+        val replay = registry.tiCloudStorageReplay(id.toInt()) ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
         return replay.play(startTimeMs.toLong(), endTimeMs.toLong(), initialTimeMs?.toLong()).toDouble()
     }
 
-    override fun storeReplayPause(id: Double): Double = registry.storeReplay(id.toInt())?.pause().normalized()
+    override fun tiCloudStorageReplayPause(id: Double): Double = registry.tiCloudStorageReplay(id.toInt())?.pause().normalized()
 
-    override fun storeReplayResume(id: Double): Double = registry.storeReplay(id.toInt())?.resume().normalized()
+    override fun tiCloudStorageReplayResume(id: Double): Double = registry.tiCloudStorageReplay(id.toInt())?.resume().normalized()
 
-    override fun storeReplaySeek(id: Double, timeMs: Double): Double =
-        registry.storeReplay(id.toInt())?.seek(timeMs.toLong()).normalized()
+    override fun tiCloudStorageReplaySeek(id: Double, timeMs: Double): Double =
+        registry.tiCloudStorageReplay(id.toInt())?.seek(timeMs.toLong()).normalized()
 
-    override fun storeReplaySetSpeed(id: Double, speed: Double): Double {
+    override fun tiCloudStorageReplaySetSpeed(id: Double, speed: Double): Double {
         val value = when (speed.toInt()) {
-            0 -> TiStoreReplaySpeed.X1
-            1 -> TiStoreReplaySpeed.X2
-            2 -> TiStoreReplaySpeed.X4
-            3 -> TiStoreReplaySpeed.X8
+            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.storeReplay(id.toInt())?.setSpeed(value).normalized()
+        return registry.tiCloudStorageReplay(id.toInt())?.setSpeed(value).normalized()
     }
 
-    override fun storeReplayStartRecording(
+    override fun tiCloudStorageReplayStartRecording(
         id: Double,
         videoChannelId: Double,
         audioChannelId: Double?,
     ): WritableMap {
-        val replay = registry.storeReplay(id.toInt())
+        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)
@@ -281,85 +291,85 @@ class TiRtcModule(
     }
 
     @ReactMethod
-    override fun storeRecordingTaskStop(id: Double, promise: Promise) {
+    override fun tiCloudStorageRecordingTaskStop(id: Double, promise: Promise) {
         val objectId = id.toInt()
-        val task = registry.storeRecordingTask(objectId)
+        val task = registry.tiCloudStorageRecordingTask(objectId)
         if (task == null) {
             promise.resolve(mp4Result(TiRtcReactNativeErrors.OBJECT_RELEASED, null, null, null))
             return
         }
         task.stop { result ->
             registry.release(objectId)
-            resolveStoreRecording(promise, result)
+            resolveCloudStorageRecording(promise, result)
         }
     }
 
-    override fun storeReplayStop(id: Double): Double = registry.storeReplay(id.toInt())?.stop().normalized()
+    override fun tiCloudStorageReplayStop(id: Double): Double = registry.tiCloudStorageReplay(id.toInt())?.stop().normalized()
 
-    override fun storeReplayDispose(id: Double): Double {
+    override fun tiCloudStorageReplayDispose(id: Double): Double {
         val objectId = id.toInt()
-        val code = registry.storeReplay(objectId)?.dispose().normalized()
+        val code = registry.tiCloudStorageReplay(objectId)?.dispose().normalized()
         if (code.toInt() == TiRtcReactNativeErrors.OK) registry.release(objectId)
         return code
     }
 
-    override fun storeCreateAudioOutput(): WritableMap =
+    override fun tiCloudStorageCreateAudioOutput(): WritableMap =
         registerReactNativeObject(
             registry,
-            factory = { TiStoreAudioOutput() },
-            onRegistered = { entry, value -> eventBinder.wireStoreAudioOutput(entry.id, value as TiStoreAudioOutput) },
+            factory = { TiCloudStorageAudioOutput() },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorageAudioOutput(entry.id, value as TiCloudStorageAudioOutput) },
         )
 
-    override fun storeAudioOutputGetState(id: Double): WritableMap {
-        val output = registry.storeAudioOutput(id.toInt())
+    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 storeAudioOutputSetVolume(id: Double, volumePercent: Double): Double =
-        registry.storeAudioOutput(id.toInt())?.setVolume(volumePercent.toInt()).normalized()
+    override fun tiCloudStorageAudioOutputSetVolume(id: Double, volumePercent: Double): Double =
+        registry.tiCloudStorageAudioOutput(id.toInt())?.setVolume(volumePercent.toInt()).normalized()
 
-    override fun storeAudioOutputAttach(outputId: Double, replayId: Double, channelId: Double): Double {
-        val replay = registry.storeReplay(replayId.toInt())
+    override fun tiCloudStorageAudioOutputAttach(outputId: Double, replayId: Double, channelId: Double): Double {
+        val replay = registry.tiCloudStorageReplay(replayId.toInt())
             ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
-        return registry.storeAudioOutput(outputId.toInt())?.attach(replay, channelId.toInt()).normalized()
+        return registry.tiCloudStorageAudioOutput(outputId.toInt())?.attach(replay, channelId.toInt()).normalized()
     }
 
-    override fun storeAudioOutputDetach(outputId: Double): Double =
-        registry.storeAudioOutput(outputId.toInt())?.detach().normalized()
+    override fun tiCloudStorageAudioOutputDetach(outputId: Double): Double =
+        registry.tiCloudStorageAudioOutput(outputId.toInt())?.detach().normalized()
 
-    override fun storeAudioOutputDispose(id: Double): Double {
+    override fun tiCloudStorageAudioOutputDispose(id: Double): Double {
         val objectId = id.toInt()
-        val code = registry.storeAudioOutput(objectId)?.dispose().normalized()
+        val code = registry.tiCloudStorageAudioOutput(objectId)?.dispose().normalized()
         if (code.toInt() == TiRtcReactNativeErrors.OK) registry.release(objectId)
         return code
     }
 
-    override fun storeCreateVideoOutput(): WritableMap =
+    override fun tiCloudStorageCreateVideoOutput(): WritableMap =
         registerReactNativeObject(
             registry,
-            factory = { TiStoreVideoOutput() },
-            onRegistered = { entry, value -> eventBinder.wireStoreVideoOutput(entry.id, value as TiStoreVideoOutput) },
+            factory = { TiCloudStorageVideoOutput() },
+            onRegistered = { entry, value -> eventBinder.wireCloudStorageVideoOutput(entry.id, value as TiCloudStorageVideoOutput) },
         )
 
-    override fun storeVideoOutputGetState(id: Double): WritableMap {
-        val output = registry.storeVideoOutput(id.toInt())
+    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 storeVideoOutputAttach(outputId: Double, replayId: Double, channelId: Double): Double {
-        val replay = registry.storeReplay(replayId.toInt())
+    override fun tiCloudStorageVideoOutputAttach(outputId: Double, replayId: Double, channelId: Double): Double {
+        val replay = registry.tiCloudStorageReplay(replayId.toInt())
             ?: return TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble()
-        return registry.storeVideoOutput(outputId.toInt())?.attach(replay, channelId.toInt()).normalized()
+        return registry.tiCloudStorageVideoOutput(outputId.toInt())?.attach(replay, channelId.toInt()).normalized()
     }
 
-    override fun storeVideoOutputDetach(outputId: Double): Double =
-        registry.storeVideoOutput(outputId.toInt())?.detach().normalized()
+    override fun tiCloudStorageVideoOutputDetach(outputId: Double): Double =
+        registry.tiCloudStorageVideoOutput(outputId.toInt())?.detach().normalized()
 
     @ReactMethod
-    override fun storeVideoOutputTakeSnapshot(id: Double, promise: Promise) {
-        val output = registry.storeVideoOutput(id.toInt())
+    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
@@ -374,14 +384,40 @@ class TiRtcModule(
         }
     }
 
-    override fun storeVideoOutputDispose(id: Double): Double {
+    override fun tiCloudStorageVideoOutputDispose(id: Double): Double {
         val objectId = id.toInt()
-        val code = registry.storeVideoOutput(objectId)?.dispose().normalized()
+        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 resolveStoreRecording(promise: Promise, result: TiStoreRecordingResult) {
+    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 }
         }
@@ -485,14 +521,14 @@ class TiRtcModule(
         val path = when (mediaFile) {
             is TiRtcRecordingFile -> mediaFile.path
             is TiRtcSnapshotFile -> mediaFile.path
-            is TiStoreRecordingFile -> mediaFile.path
-            is TiStoreSnapshotFile -> 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 TiStoreRecordingFile
+        val video = mediaFile is TiRtcRecordingFile || mediaFile is TiCloudStorageRecordingFile
         val normalizedName = normalizeGalleryFileName(fileName, video)
         if (normalizedName == null) {
             promise.resolve(galleryResult(ERROR_INVALID_ARGUMENT, null))
@@ -610,8 +646,8 @@ class TiRtcModule(
         when (mediaFile) {
             is TiRtcRecordingFile -> mediaFile.delete(onDelete)
             is TiRtcSnapshotFile -> mediaFile.delete(onDelete)
-            is TiStoreRecordingFile -> mediaFile.delete(onDelete)
-            is TiStoreSnapshotFile -> mediaFile.delete(onDelete)
+            is TiCloudStorageRecordingFile -> mediaFile.delete(onDelete)
+            is TiCloudStorageSnapshotFile -> mediaFile.delete(onDelete)
         }
     }
 
@@ -626,8 +662,8 @@ class TiRtcModule(
         when (mediaFile) {
             is TiRtcRecordingFile -> mediaFile.delete(callback)
             is TiRtcSnapshotFile -> mediaFile.delete(callback)
-            is TiStoreRecordingFile -> mediaFile.delete(callback)
-            is TiStoreSnapshotFile -> mediaFile.delete(callback)
+            is TiCloudStorageRecordingFile -> mediaFile.delete(callback)
+            is TiCloudStorageSnapshotFile -> mediaFile.delete(callback)
             else -> promise.resolve(TiRtcReactNativeErrors.OBJECT_RELEASED.toDouble())
         }
     }
@@ -989,6 +1025,7 @@ 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

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

@@ -12,13 +12,13 @@ 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 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 {
@@ -44,8 +44,8 @@ internal object TiRtcReactNativeCleanup {
             when (file) {
                 is TiRtcRecordingFile -> file.delete(completed)
                 is TiRtcSnapshotFile -> file.delete(completed)
-                is TiStoreRecordingFile -> file.delete(completed)
-                is TiStoreSnapshotFile -> file.delete(completed)
+                is TiCloudStorageRecordingFile -> file.delete(completed)
+                is TiCloudStorageSnapshotFile -> file.delete(completed)
                 else -> finish()
             }
         }
@@ -60,14 +60,14 @@ internal object TiRtcReactNativeCleanup {
                         finish()
                     }
                 }
-                is TiStoreRecordingTask -> {
+                is TiCloudStorageRecordingTask -> {
                     retain()
                     value.stop { result ->
                         delete(result.file)
                         finish()
                     }
                 }
-                is StoreExportBridge -> {
+                is CloudStorageExportBridge -> {
                     retain()
                     value.invalidate { result ->
                         delete(result?.file)
@@ -80,29 +80,29 @@ internal object TiRtcReactNativeCleanup {
     }
 
     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<TiCloudStorageAudioOutput>().forEach { output ->
+            logFailure("ti-cloud-storage-audio-detach", output.detach())
+            logFailure("ti-cloud-storage-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<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<TiStoreReplay>().forEach { replay ->
-            logFailure("store_replay_stop", replay.stop())
-            logFailure("store_replay_dispose", replay.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<TiStore>().forEach { logFailure("store_dispose", it.dispose()) }
-        logFailure("store_shutdown", TiStore.shutdown())
+        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")
     }