tirtc-react-native 2.4.2 → 2.5.0

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

@@ -4,11 +4,121 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.tange.ai.tirtc.TiCloudStorageRecordingRange
 import com.tange.ai.tirtc.TiCloudStorageRecordingDay
+import com.tange.ai.tirtc.TiCloudStorageRecordingGap
+import com.tange.ai.tirtc.TiCloudStorageExportProgress
+import com.tange.ai.tirtc.TiCloudStorageExportReport
+import com.tange.ai.tirtc.TiCloudStorageExportResult
+import com.tange.ai.tirtc.TiRawDumpArchive
 
-internal fun recordingStartResult(code: Int, taskId: Int?): WritableMap =
+internal fun recordingStartResult(code: Int, taskId: Int?, generation: Int = 0): WritableMap =
     Arguments.createMap().apply {
         putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
         if (taskId == null) putNull("taskId") else putInt("taskId", taskId)
+        putInt("generation", generation)
+    }
+
+internal fun rawDumpStartResult(code: Int, dumpId: Int?): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        if (dumpId == null) putNull("dumpId") else putInt("dumpId", dumpId)
+    }
+
+private fun rawDumpArchive(value: TiRawDumpArchive): WritableMap =
+    Arguments.createMap().apply {
+        putString("captureId", value.captureId)
+        putString("path", value.path)
+        putDouble("size", value.size.toDouble())
+        putString("sha256", value.sha256)
+        putDouble("capturedDurationMs", value.capturedDurationMs.toDouble())
+        putBoolean("captureComplete", value.captureComplete)
+        putInt("stopReason", value.stopReason.ordinal)
+        putDouble("unsavedPacketCount", value.unsavedPacketCount.toDouble())
+        putDouble("unsavedByteCount", value.unsavedByteCount.toDouble())
+        putBoolean("empty", value.empty)
+    }
+
+internal fun rawDumpStopResult(
+    code: Int,
+    value: TiRawDumpArchive?,
+    terminal: Boolean = false,
+): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(code))
+        if (value == null) putNull("archive") else putMap("archive", rawDumpArchive(value))
+        putBoolean("terminal", terminal)
+    }
+
+private fun tiCloudStorageRecordingRange(range: TiCloudStorageRecordingRange): WritableMap =
+    Arguments.createMap().apply {
+        putDouble("startTimeMs", range.startTimeMs.toDouble())
+        putDouble("endTimeMs", range.endTimeMs.toDouble())
+    }
+
+internal fun tiCloudStorageRecordingGap(gap: TiCloudStorageRecordingGap): WritableMap =
+    Arguments.createMap().apply {
+        putMap("range", tiCloudStorageRecordingRange(gap.range))
+        putArray("tracks", Arguments.createArray().apply {
+            gap.tracks.forEach { track ->
+                pushMap(Arguments.createMap().apply {
+                    putInt("kind", track.kind.ordinal + 1)
+                    putInt("channelId", track.channelId)
+                })
+            }
+        })
+        putArray("reasons", Arguments.createArray().apply {
+            gap.reasons.forEach { pushInt(it.ordinal) }
+        })
+    }
+
+internal fun tiCloudStorageExportProgress(progress: TiCloudStorageExportProgress): WritableMap =
+    Arguments.createMap().apply {
+        putDouble("fraction", progress.fraction)
+        putDouble("coveredDurationMs", progress.coveredDurationMs.toDouble())
+    }
+
+private fun tiCloudStorageExportReport(report: TiCloudStorageExportReport): WritableMap =
+    Arguments.createMap().apply {
+        putMap("requestedRange", tiCloudStorageRecordingRange(report.requestedRange))
+        putDouble("coveredDurationMs", report.coveredDurationMs.toDouble())
+        putArray("segments", Arguments.createArray().apply {
+            report.segments.forEach { segment ->
+                pushMap(Arguments.createMap().apply {
+                    putMap("sourceRange", tiCloudStorageRecordingRange(segment.sourceRange))
+                    putDouble("outputStartMs", segment.outputStartMs.toDouble())
+                    putDouble("outputEndMs", segment.outputEndMs.toDouble())
+                })
+            }
+        })
+        putArray("gaps", Arguments.createArray().apply {
+            report.gaps.forEach { pushMap(tiCloudStorageRecordingGap(it)) }
+        })
+        putArray("unprocessedRanges", Arguments.createArray().apply {
+            report.unprocessedRanges.forEach { pushMap(tiCloudStorageRecordingRange(it)) }
+        })
+        putBoolean("complete", report.complete)
+        putInt("termination", report.termination.ordinal)
+        putInt("cause", TiRtcReactNativeErrors.normalizeAndroid(report.cause))
+    }
+
+internal fun tiCloudStorageExportResult(
+    result: TiCloudStorageExportResult,
+    fileId: Int?,
+    progress: TiCloudStorageExportProgress?,
+): WritableMap =
+    Arguments.createMap().apply {
+        putInt("code", TiRtcReactNativeErrors.normalizeAndroid(result.code))
+        if (fileId == null) putNull("fileId") else putInt("fileId", fileId)
+        val file = result.file
+        val report = result.report
+        if (file == null) {
+            putNull("filePath")
+            putNull("durationMs")
+        } else {
+            putString("filePath", file.path)
+            putDouble("durationMs", file.durationMs.toDouble())
+        }
+        if (report == null) putNull("report") else putMap("report", tiCloudStorageExportReport(report))
+        if (progress == null) putNull("progressDetail") else putMap("progressDetail", tiCloudStorageExportProgress(progress))
     }
 
 internal fun tiCloudStorageRecordingsResult(code: Int, ranges: List<TiCloudStorageRecordingRange>): WritableMap =
@@ -16,10 +126,7 @@ internal fun tiCloudStorageRecordingsResult(code: Int, ranges: List<TiCloudStora
         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())
-                })
+                pushMap(tiCloudStorageRecordingRange(range))
             }
         })
     }

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

@@ -12,7 +12,6 @@ import com.tange.ai.tirtc.TiRtcAudioSampleRate
 import com.tange.ai.tirtc.TiRtcCameraFacing
 import com.tange.ai.tirtc.TiRtcOutputBufferStrategy
 import com.tange.ai.tirtc.TiRtcVideoDecoderPreference
-import com.tange.ai.tirtc.TiRtcVideoEncoderCodec
 import com.tange.ai.tirtc.TiRtcVideoFrameRate
 import com.tange.ai.tirtc.TiRtcVideoInputOptions
 import com.tange.ai.tirtc.TiRtcVideoOutputOptions
@@ -59,16 +58,12 @@ internal fun audioInputOptions(options: ReadableMap): TiRtcAudioInputOptions {
             },
         agcLevel = audioAgcLevel(options.getString("agcLevel")),
         ansLevel = audioAnsLevel(options.getString("ansLevel")),
-    )
+    ).apply { media = options.getInt("media") }
 }
 
 internal fun videoInputOptions(options: ReadableMap): TiRtcVideoInputOptions {
     return TiRtcVideoInputOptions(
-        codec =
-            when (options.getString("codec")) {
-                "mjpeg" -> TiRtcVideoEncoderCodec.MJPEG
-                else -> TiRtcVideoEncoderCodec.H264
-            },
+        media = options.getInt("media"),
         width = options.getInt("width"),
         height = options.getInt("height"),
         frameRate =

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

@@ -6,6 +6,7 @@ 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.TiRawDump
 import com.tange.ai.tirtc.TiCloudStorage
 import com.tange.ai.tirtc.TiCloudStorageAudioOutput
 import com.tange.ai.tirtc.TiCloudStorageRecordingTask
@@ -63,6 +64,8 @@ internal object TiRtcReactNativeRegistry {
 
     fun recordingTask(id: Int): TiRtcRecordingTask? = entries[id]?.value as? TiRtcRecordingTask
 
+    fun rawDump(id: Int): TiRawDump? = entries[id]?.value as? TiRawDump
+
     fun cloudStorage(id: Int): TiCloudStorage? = entries[id]?.value as? TiCloudStorage
 
     fun tiCloudStorageReplay(id: Int): TiCloudStorageReplay? = entries[id]?.value as? TiCloudStorageReplay

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

@@ -2,19 +2,49 @@ package com.tange.ai.tirtc.reactnative
 
 import com.facebook.react.bridge.Promise
 import com.tange.ai.tirtc.TiCloudStorageExportTask
-import com.tange.ai.tirtc.TiCloudStorageRecordingResult
+import com.tange.ai.tirtc.TiCloudStorageExportProgress
+import com.tange.ai.tirtc.TiCloudStorageExportResult
+import com.tange.ai.tirtc.TiCloudStorageRecordingGap
 
 internal class CloudStorageExportBridge(
-    private val resolve: (Promise, TiCloudStorageRecordingResult) -> Unit,
+    private val resolve: (Promise, TiCloudStorageExportResult, TiCloudStorageExportProgress?) -> Unit,
+    private val events: TiRtcReactNativeEventSink,
 ) {
     @Volatile var task: TiCloudStorageExportTask? = null
+        private set
     @Volatile var onDrained: (() -> Unit)? = null
-    private var result: TiCloudStorageRecordingResult? = null
+    private var result: TiCloudStorageExportResult? = null
     private val waiters = mutableListOf<Promise>()
     private var invalidated = false
-    private var invalidationCompletion: ((TiCloudStorageRecordingResult?) -> Unit)? = null
+    private var startRejected = false
+    private var invalidationCompletion: ((TiCloudStorageExportResult?) -> Unit)? = null
+    var objectId = 0
 
-    fun complete(value: TiCloudStorageRecordingResult) {
+    fun bindTask(value: TiCloudStorageExportTask) {
+        val cancel = synchronized(this) {
+            task = value
+            invalidated
+        }
+        if (cancel) value.cancel()
+    }
+
+    fun rejectStart() {
+        val completed = synchronized(this) {
+            startRejected = true
+            invalidationCompletion.also { invalidationCompletion = null }
+        }
+        completed?.invoke(null)
+    }
+
+    fun progress(value: TiCloudStorageExportProgress) {
+        events.tiCloudStorageExportProgress(objectId, value)
+    }
+
+    fun recordingGap(value: TiCloudStorageRecordingGap) {
+        events.tiCloudStorageExportRecordingGap(objectId, value)
+    }
+
+    fun complete(value: TiCloudStorageExportResult) {
         val completed = synchronized(this) {
             if (result != null) return
             result = value
@@ -22,7 +52,7 @@ internal class CloudStorageExportBridge(
             waiters.clear()
             pending to invalidationCompletion.also { invalidationCompletion = null }
         }
-        completed.first.forEach { resolve(it, value) }
+        completed.first.forEach { resolve(it, value, task?.progressDetail) }
         if (completed.first.isNotEmpty()) onDrained?.invoke()
         completed.second?.invoke(value)
     }
@@ -35,30 +65,24 @@ internal class CloudStorageExportBridge(
             }
         }
         if (completed != null) {
-            resolve(promise, completed)
+            resolve(promise, completed, task?.progressDetail)
             onDrained?.invoke()
         }
     }
 
-    fun invalidate(onTerminal: (TiCloudStorageRecordingResult?) -> Unit) {
-        val completed = synchronized(this) {
+    fun invalidate(onTerminal: (TiCloudStorageExportResult?) -> Unit) {
+        val state = synchronized(this) {
             invalidated = true
             waiters.clear()
-            result?.also { return@synchronized it } ?: run {
-                invalidationCompletion = onTerminal
-                null
-            }
+            if (result == null && !startRejected) invalidationCompletion = onTerminal
+            Triple(result, startRejected, task)
         }
-        if (completed != null) {
-            onTerminal(completed)
+        if (state.first != null || state.second) {
+            onTerminal(state.first)
             return
         }
-        val code = task?.stop() ?: TiRtcReactNativeErrors.OBJECT_RELEASED
-        if (code != 0) {
-            synchronized(this) {
-                invalidationCompletion = null
-            }
-            onTerminal(null)
-        }
+        // An accepted task always reaches completion. If start is still in
+        // flight, bindTask requests cancellation once its handle is available.
+        state.third?.cancel()
     }
 }

package/ios/TiRtcReactNative+Conn.mm

@@ -39,6 +39,19 @@ static NSString* TiRtcReactNativeGalleryFileName(NSString* fileName, BOOL video)
 #pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
 @implementation TiRtcReactNative (Conn)
 
+static NSDictionary* TiRtcReactNativeRawDumpArchiveResult(TiRawDumpStopResult* result) {
+  TiRawDumpArchive* value = result.archive;
+  if (value == nil) return @{ @"code": @(TiRtcReactNativeNormalizeDarwin(result.code)),
+                              @"archive": (id)kCFNull, @"terminal": @NO };
+  return @{ @"code": @0, @"archive": @{
+    @"captureId": value.captureId, @"path": value.path, @"size": @(value.size),
+    @"sha256": value.sha256, @"capturedDurationMs": @(value.capturedDurationMs),
+    @"captureComplete": @(value.captureComplete), @"stopReason": @(value.stopReason),
+    @"unsavedPacketCount": @(value.unsavedPacketCount),
+    @"unsavedByteCount": @(value.unsavedByteCount), @"empty": @(value.empty),
+  }, @"terminal": @NO };
+}
+
 - (NSDictionary*)createConn {
   return [self
       registerObject:^id {
@@ -147,6 +160,54 @@ static NSString* TiRtcReactNativeGalleryFileName(NSString* fileName, BOOL video)
   return @{@"code" : @(TiRtcReactNativeErrorOK), @"taskId" : @(taskId)};
 }
 
+- (void)connStartRawDump:(double)objectId
+          audioStreamIds:(NSArray*)audioStreamIds
+          videoStreamIds:(NSArray*)videoStreamIds
+      uplinkAudioStreamIds:(NSArray*)uplinkAudioStreamIds
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  TiRtcConn* conn = [self conn:objectId];
+  if (conn == nil) {
+    resolve(@{ @"code": @(TiRtcReactNativeErrorObjectReleased), @"dumpId": (id)kCFNull });
+    return;
+  }
+  TiRtcRawDumpOptions* options = [[TiRtcRawDumpOptions alloc]
+      initWithAudioStreamIds:audioStreamIds
+              videoStreamIds:videoStreamIds
+        uplinkAudioStreamIds:uplinkAudioStreamIds];
+  [conn startRawDumpWithOptions:options completion:^(TiRawDumpStartResult* result) {
+    if (result.code != 0 || result.dump == nil) {
+      resolve(@{ @"code": @(TiRtcReactNativeNormalizeDarwin(result.code)),
+                 @"dumpId": (id)kCFNull });
+      return;
+    }
+    NSInteger dumpId = [[self registry] addObject:result.dump];
+    resolve(@{ @"code": @0, @"dumpId": @(dumpId) });
+  }];
+}
+
+- (void)rawDumpStop:(double)objectId
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiRawDump class]]) {
+    resolve(@{
+      @"code": @(TiRtcReactNativeErrorObjectReleased),
+      @"archive": (id)kCFNull,
+      @"terminal": @NO
+    });
+    return;
+  }
+  [(TiRawDump*)object stopWithCompletion:^(TiRawDumpStopResult* result) {
+    BOOL terminal = result.code != [TiCloudStorageErrorCode inUse];
+    NSMutableDictionary* payload =
+        [TiRtcReactNativeRawDumpArchiveResult(result) mutableCopy];
+    payload[@"terminal"] = @(terminal);
+    if (terminal) [[self registry] releaseObject:(NSInteger)objectId];
+    resolve(payload);
+  }];
+}
+
 - (void)recordingTaskStop:(double)objectId
                   resolve:(RCTPromiseResolveBlock)resolve
                    reject:(RCTPromiseRejectBlock)reject {

package/ios/TiRtcReactNative+Output.mm

@@ -182,13 +182,7 @@
   }
   dispatch_async(dispatch_get_main_queue(), ^{
     [output takeSnapshotWithCompletion:^(TiRtcSnapshotResult* snapshotResult) {
-      NSInteger fileId =
-          snapshotResult.file == nil ? 0 : [[self registry] addTransientObject:snapshotResult.file];
-      resolve(@{
-        @"code" : @(TiRtcReactNativeNormalizeDarwin(snapshotResult.code)),
-        @"fileId" : fileId == 0 ? (id)kCFNull : @(fileId),
-        @"filePath" : snapshotResult.file.path ?: (id)kCFNull
-      });
+      resolve([self snapshotResultWithCode:snapshotResult.code file:snapshotResult.file]);
     }];
   });
 }

package/ios/TiRtcReactNative+Private.h

@@ -28,5 +28,6 @@
 - (TiRtcVideoOutput*)videoOutput:(double)objectId;
 - (TiRtcAudioInput*)audioInput:(double)objectId;
 - (TiRtcVideoInput*)videoInput:(double)objectId;
+- (NSDictionary*)snapshotResultWithCode:(int32_t)code file:(id)file;
 
 @end

package/ios/TiRtcReactNative+Storage.mm

@@ -76,31 +76,79 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
   };
 }
 
+static NSDictionary* TiRtcReactNativeCloudStorageExportResult(
+    TiRtcReactNativeRegistry* registry, TiCloudStorageExportResult* result,
+    TiCloudStorageExportProgress* progress) {
+  NSInteger fileId = result.file == nil ? 0 : [registry addTransientObject:result.file];
+  return @{
+    @"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)),
+    @"fileId" : fileId == 0 ? (id)kCFNull : @(fileId),
+    @"filePath" : result.file.path ?: (id)kCFNull,
+    @"durationMs" : result.file == nil ? (id)kCFNull : @(result.file.durationMs),
+    @"report" : result.report == nil ? (id)kCFNull : TiRtcReactNativeCloudStorageExportReport(result.report),
+    @"progressDetail" : progress == nil ? (id)kCFNull : TiRtcReactNativeCloudStorageExportProgress(progress),
+  };
+}
+
 @interface TiRtcReactNativeCloudStorageExportBridge : NSObject <TiRtcReactNativeReloadTask>
 @property(nonatomic, strong) TiCloudStorageExportTask* task;
 @property(nonatomic, assign) NSInteger objectId;
-- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry;
-- (void)complete:(TiCloudStorageRecordingResult*)result;
+- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry binder:(TiRtcReactNativeEventBinder*)binder;
+- (void)bindTask:(TiCloudStorageExportTask*)task;
+- (void)rejectStart;
+- (void)progress:(TiCloudStorageExportProgress*)progress;
+- (void)recordingGap:(TiCloudStorageRecordingGap*)gap;
+- (void)complete:(TiCloudStorageExportResult*)result;
 - (void)await:(RCTPromiseResolveBlock)resolve;
 @end
 
 @implementation TiRtcReactNativeCloudStorageExportBridge {
   TiRtcReactNativeRegistry* _registry;
-  TiCloudStorageRecordingResult* _result;
+  TiRtcReactNativeEventBinder* _binder;
+  TiCloudStorageExportResult* _result;
   NSMutableArray<RCTPromiseResolveBlock>* _waiters;
   BOOL _invalidated;
+  BOOL _startRejected;
   void (^_invalidationCompletion)(id file);
 }
 
-- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry {
+- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry binder:(TiRtcReactNativeEventBinder*)binder {
   if (self = [super init]) {
     _registry = registry;
+    _binder = binder;
     _waiters = [NSMutableArray new];
   }
   return self;
 }
 
-- (void)complete:(TiCloudStorageRecordingResult*)result {
+- (void)bindTask:(TiCloudStorageExportTask*)task {
+  BOOL cancel;
+  @synchronized(self) {
+    self.task = task;
+    cancel = _invalidated;
+  }
+  if (cancel) [task cancel];
+}
+
+- (void)rejectStart {
+  void (^completion)(id file);
+  @synchronized(self) {
+    _startRejected = YES;
+    completion = _invalidationCompletion;
+    _invalidationCompletion = nil;
+  }
+  if (completion != nil) completion(nil);
+}
+
+- (void)progress:(TiCloudStorageExportProgress*)progress {
+  [_binder cloudStorageExportProgress:progress objectId:self.objectId];
+}
+
+- (void)recordingGap:(TiCloudStorageRecordingGap*)gap {
+  [_binder cloudStorageExportRecordingGap:gap objectId:self.objectId];
+}
+
+- (void)complete:(TiCloudStorageExportResult*)result {
   NSArray<RCTPromiseResolveBlock>* waiters;
   void (^invalidationCompletion)(id file);
   @synchronized(self) {
@@ -112,14 +160,14 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
     _invalidationCompletion = nil;
   }
   for (RCTPromiseResolveBlock resolve in waiters) {
-    resolve(TiRtcReactNativeCloudStorageMp4Result(_registry, result));
+    resolve(TiRtcReactNativeCloudStorageExportResult(_registry, result, self.task.progressDetail));
   }
   if (waiters.count > 0 && self.objectId > 0) [_registry releaseObject:self.objectId];
   if (invalidationCompletion != nil) invalidationCompletion(result.file);
 }
 
 - (void)await:(RCTPromiseResolveBlock)resolve {
-  TiCloudStorageRecordingResult* result;
+  TiCloudStorageExportResult* result;
   @synchronized(self) {
     result = _result;
     if (result == nil) {
@@ -127,29 +175,28 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
       return;
     }
   }
-  resolve(TiRtcReactNativeCloudStorageMp4Result(_registry, result));
+  resolve(TiRtcReactNativeCloudStorageExportResult(_registry, result, self.task.progressDetail));
   if (self.objectId > 0) [_registry releaseObject:self.objectId];
 }
 
 - (void)stopForReactNativeInvalidation:(void (^)(id file))completion {
-  TiCloudStorageRecordingResult* result;
+  TiCloudStorageExportResult* result;
+  TiCloudStorageExportTask* task;
+  BOOL rejected;
   @synchronized(self) {
     _invalidated = YES;
     [_waiters removeAllObjects];
     result = _result;
-    if (result == nil) _invalidationCompletion = [completion copy];
+    task = self.task;
+    rejected = _startRejected;
+    if (result == nil && !rejected) _invalidationCompletion = [completion copy];
   }
-  if (result != nil) {
+  if (result != nil || rejected) {
     completion(result.file);
     return;
   }
-  int32_t code = [self.task stop];
-  if (code != 0) {
-    @synchronized(self) {
-      _invalidationCompletion = nil;
-    }
-    completion(nil);
-  }
+  // bindTask cancels after an in-flight start returns its accepted handle.
+  [task cancel];
 }
 
 @end
@@ -240,7 +287,7 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
     return TiRtcReactNativeCreateResult(TiRtcReactNativeErrorObjectReleased, 0, 0, nil);
   }
   return [self
-      registerObject:^id { return [(TiCloudStorage*)object createReplay]; }
+      registerObject:^id { return [(TiCloudStorage*)object createReplayWithCallbackThread:TiCloudStorageCallbackThreadBackground]; }
       wire:^id(NSInteger replayId, id replay) {
         return [[self eventBinder] wireCloudStorageReplay:(TiCloudStorageReplay*)replay objectId:replayId];
       }];
@@ -253,25 +300,34 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
                         audioChannelId:(NSNumber*)audioChannelId {
   id object = [[self registry] objectForId:(NSInteger)objectId];
   if (![object isKindOfClass:[TiCloudStorage class]]) {
-    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull};
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull, @"generation" : @0};
   }
   TiRtcReactNativeCloudStorageExportBridge* bridge =
-      [[TiRtcReactNativeCloudStorageExportBridge alloc] initWithRegistry:[self registry]];
+      [[TiRtcReactNativeCloudStorageExportBridge alloc] initWithRegistry:[self registry]
+                                                                  binder:[self eventBinder]];
   TiCloudStorageExportRequest* request = [[TiCloudStorageExportRequest alloc]
       initWithStartTimeMs:(int64_t)startTimeMs
       endTimeMs:(int64_t)endTimeMs
       videoChannelId:(NSInteger)videoChannelId
       audioChannelId:audioChannelId];
+  NSInteger generation = 0;
+  NSInteger taskId = [[self registry] addObject:bridge generation:&generation];
+  bridge.objectId = taskId;
   TiCloudStorageExportTaskStartResult* started = [(TiCloudStorage*)object
       exportRecording:request
       progress:nil
-      completion:^(TiCloudStorageRecordingResult* result) { [bridge complete:result]; }];
+      progressDetail:^(TiCloudStorageExportProgress* progress) { [bridge progress:progress]; }
+      onRecordingGap:^(TiCloudStorageRecordingGap* gap) { [bridge recordingGap:gap]; }
+      callbackThread:TiCloudStorageCallbackThreadBackground
+      completion:^(TiCloudStorageExportResult* result) { [bridge complete:result]; }];
   if (started.code != 0 || started.task == nil) {
-    return @{@"code" : @(TiRtcReactNativeNormalizeDarwin(started.code)), @"taskId" : (id)kCFNull};
+    [bridge rejectStart];
+    [[self registry] releaseObject:taskId];
+    return @{@"code" : @(TiRtcReactNativeNormalizeDarwin(started.code)), @"taskId" : (id)kCFNull,
+             @"generation" : @0};
   }
-  bridge.task = started.task;
-  bridge.objectId = [[self registry] addObject:bridge];
-  return @{@"code" : @0, @"taskId" : @(bridge.objectId)};
+  [bridge bindTask:started.task];
+  return @{@"code" : @0, @"taskId" : @(taskId), @"generation" : @(generation)};
 }
 
 - (NSNumber*)tiCloudStorageExportProgress:(double)objectId {
@@ -281,13 +337,23 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
              : @0;
 }
 
+- (NSDictionary*)tiCloudStorageExportProgressDetail:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  TiCloudStorageExportProgress* progress =
+      [object isKindOfClass:[TiRtcReactNativeCloudStorageExportBridge class]]
+          ? ((TiRtcReactNativeCloudStorageExportBridge*)object).task.progressDetail
+          : [[TiCloudStorageExportProgress alloc] initWithFraction:0 coveredDurationMs:0];
+  return TiRtcReactNativeCloudStorageExportProgress(progress);
+}
+
 - (void)tiCloudStorageExportResult:(double)objectId
                    resolve:(RCTPromiseResolveBlock)resolve
                     reject:(RCTPromiseRejectBlock)reject {
   id object = [[self registry] objectForId:(NSInteger)objectId];
   if (![object isKindOfClass:[TiRtcReactNativeCloudStorageExportBridge class]]) {
     resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"fileId" : (id)kCFNull,
-              @"filePath" : (id)kCFNull, @"durationMs" : (id)kCFNull});
+              @"filePath" : (id)kCFNull, @"durationMs" : (id)kCFNull, @"report" : (id)kCFNull,
+              @"progressDetail" : (id)kCFNull});
     return;
   }
   [(TiRtcReactNativeCloudStorageExportBridge*)object await:resolve];
@@ -302,6 +368,15 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
   return @(TiRtcReactNativeNormalizeDarwin([task stop]));
 }
 
+- (NSNumber*)tiCloudStorageExportCancel:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiRtcReactNativeCloudStorageExportBridge class]]) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  TiCloudStorageExportTask* task = ((TiRtcReactNativeCloudStorageExportBridge*)object).task;
+  return @(TiRtcReactNativeNormalizeDarwin([task cancel]));
+}
+
 - (NSNumber*)tiCloudStorageDispose:(double)objectId {
   id object = [[self registry] objectForId:(NSInteger)objectId];
   if (![object isKindOfClass:[TiCloudStorage class]]) return @(TiRtcReactNativeErrorObjectReleased);
@@ -358,15 +433,41 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
                               audioChannelId:(NSNumber*)audioChannelId {
   id object = [[self registry] objectForId:(NSInteger)objectId];
   if (![object isKindOfClass:[TiCloudStorageReplay class]]) {
-    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull};
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull, @"generation" : @0};
   }
   TiCloudStorageRecordingTaskStartResult* started = [(TiCloudStorageReplay*)object
       startRecordingWithVideoChannelId:(NSInteger)videoChannelId audioChannelId:audioChannelId];
   if (started.code != 0 || started.task == nil) {
-    return @{@"code" : @(TiRtcReactNativeNormalizeDarwin(started.code)), @"taskId" : (id)kCFNull};
+    return @{@"code" : @(TiRtcReactNativeNormalizeDarwin(started.code)), @"taskId" : (id)kCFNull,
+             @"generation" : @0};
+  }
+  NSInteger generation = 0;
+  NSInteger taskId = [[self registry] addObject:started.task generation:&generation];
+  return @{@"code" : @0, @"taskId" : @(taskId), @"generation" : @(generation)};
+}
+
+- (void)tiCloudStorageReplayStartRawDump:(double)objectId
+                         audioChannelIds:(NSArray*)audioChannelIds
+                         videoChannelIds:(NSArray*)videoChannelIds
+                                 resolve:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageReplay class]]) {
+    resolve(@{ @"code": @(TiRtcReactNativeErrorObjectReleased), @"dumpId": (id)kCFNull });
+    return;
   }
-  NSInteger taskId = [[self registry] addObject:started.task];
-  return @{@"code" : @0, @"taskId" : @(taskId)};
+  TiCloudStorageRawDumpOptions* options = [[TiCloudStorageRawDumpOptions alloc]
+      initWithAudioChannelIds:audioChannelIds videoChannelIds:videoChannelIds];
+  [(TiCloudStorageReplay*)object startRawDumpWithOptions:options
+      completion:^(TiRawDumpStartResult* result) {
+        if (result.code != 0 || result.dump == nil) {
+          resolve(@{ @"code": @(TiRtcReactNativeNormalizeDarwin(result.code)),
+                     @"dumpId": (id)kCFNull });
+          return;
+        }
+        NSInteger dumpId = [[self registry] addObject:result.dump];
+        resolve(@{ @"code": @0, @"dumpId": @(dumpId) });
+      }];
 }
 
 - (void)tiCloudStorageRecordingTaskStop:(double)objectId
@@ -491,10 +592,7 @@ static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
   TiCloudStorageVideoOutput* output = (TiCloudStorageVideoOutput*)object;
   dispatch_async(dispatch_get_main_queue(), ^{
     [output takeSnapshotWithCompletion:^(TiCloudStorageSnapshotResult* result) {
-      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});
+      resolve([self snapshotResultWithCode:result.code file:result.file]);
     }];
   });
 }