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

package/ios/TiRtcReactNative+Input.mm

@@ -91,8 +91,15 @@
                   resolve:(RCTPromiseResolveBlock)resolve
                    reject:(RCTPromiseRejectBlock)reject {
   TiRtcAudioInput* input = [self audioInput:objectId];
-  [input dispose];
-  resolve([self releaseRegisteredObject:(NSInteger)objectId object:input]);
+  if (input == nil) {
+    resolve(@(TiRtcReactNativeErrorObjectReleased));
+    return;
+  }
+  NSInteger code = TiRtcReactNativeNormalizeDarwin([input dispose]);
+  if (code == TiRtcReactNativeErrorOK) {
+    [self releaseRegisteredObject:(NSInteger)objectId object:input];
+  }
+  resolve(@(code));
 }
 
 - (NSDictionary*)createVideoInput {
@@ -188,8 +195,15 @@
                   resolve:(RCTPromiseResolveBlock)resolve
                    reject:(RCTPromiseRejectBlock)reject {
   TiRtcVideoInput* input = [self videoInput:objectId];
-  [input dispose];
-  resolve([self releaseRegisteredObject:(NSInteger)objectId object:input]);
+  if (input == nil) {
+    resolve(@(TiRtcReactNativeErrorObjectReleased));
+    return;
+  }
+  NSInteger code = TiRtcReactNativeNormalizeDarwin([input dispose]);
+  if (code == TiRtcReactNativeErrorOK) {
+    [self releaseRegisteredObject:(NSInteger)objectId object:input];
+  }
+  resolve(@(code));
 }
 
 @end

package/ios/TiRtcReactNative+Output.mm

@@ -85,8 +85,14 @@
 
 - (NSNumber*)audioOutputDispose:(double)objectId {
   TiRtcAudioOutput* output = [self audioOutput:objectId];
-  [output dispose];
-  return [self releaseRegisteredObject:(NSInteger)objectId object:output];
+  if (output == nil) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  NSInteger code = TiRtcReactNativeNormalizeDarwin([output dispose]);
+  if (code == TiRtcReactNativeErrorOK) {
+    [self releaseRegisteredObject:(NSInteger)objectId object:output];
+  }
+  return @(code);
 }
 
 - (NSDictionary*)createVideoOutput {
@@ -162,10 +168,41 @@
                        : TiRtcReactNativeVideoDebugResult([output getDebugSnapshot]);
 }
 
+- (void)videoOutputTakeSnapshot:(double)objectId
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+  TiRtcVideoOutput* output = [self videoOutput:objectId];
+  if (output == nil) {
+    resolve(@{
+      @"code" : @(TiRtcReactNativeErrorObjectReleased),
+      @"fileId" : (id)kCFNull,
+      @"filePath" : (id)kCFNull
+    });
+    return;
+  }
+  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
+      });
+    }];
+  });
+}
+
 - (NSNumber*)videoOutputDispose:(double)objectId {
   TiRtcVideoOutput* output = [self videoOutput:objectId];
-  [output dispose];
-  return [self releaseRegisteredObject:(NSInteger)objectId object:output];
+  if (output == nil) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  NSInteger code = TiRtcReactNativeNormalizeDarwin([output dispose]);
+  if (code == TiRtcReactNativeErrorOK) {
+    [self releaseRegisteredObject:(NSInteger)objectId object:output];
+  }
+  return @(code);
 }
 
 @end

package/ios/TiRtcReactNative+Private.h

@@ -3,6 +3,10 @@
 #import "TiRtcReactNativeNative.h"
 #import "TiRtcReactNativeRegistry.h"
 
+@protocol TiRtcReactNativeReloadTask <NSObject>
+- (void)stopForReactNativeInvalidation:(void (^)(id file))completion;
+@end
+
 @interface TiRtcReactNative (Private)
 
 - (TiRtcReactNativeRegistry*)registry;

package/ios/TiRtcReactNative+Storage.mm

@@ -0,0 +1,513 @@
+#import "TiRtcReactNative+Private.h"
+
+#import "TiRtcReactNativeErrors.h"
+#import "TiRtcReactNativeMaps.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
+
+static NSInteger TiRtcReactNativeCloudStorageReplaySpeedValue(TiCloudStorageReplaySpeed speed) {
+  switch (speed) {
+    case TiCloudStorageReplaySpeedX0_125: return 6;
+    case TiCloudStorageReplaySpeedX0_25: return 5;
+    case TiCloudStorageReplaySpeedX0_5: return 4;
+    case TiCloudStorageReplaySpeedX1: return 0;
+    case TiCloudStorageReplaySpeedX2: return 1;
+    case TiCloudStorageReplaySpeedX4: return 2;
+    case TiCloudStorageReplaySpeedX8: return 3;
+  }
+  return 0;
+}
+
+static int32_t TiRtcReactNativeDetachCloudStorageVideoView(TiCloudStorageVideoOutput* output) {
+  if ([NSThread isMainThread]) return [output detachView];
+  __block int32_t code = TiRtcReactNativeErrorPlatformInternal;
+  dispatch_sync(dispatch_get_main_queue(), ^{
+    code = [output detachView];
+  });
+  return code;
+}
+
+static BOOL TiRtcReactNativeCloudStorageReplaySpeedFromValue(NSInteger value, TiCloudStorageReplaySpeed* speed) {
+  switch (value) {
+    case 6: *speed = TiCloudStorageReplaySpeedX0_125; return YES;
+    case 5: *speed = TiCloudStorageReplaySpeedX0_25; return YES;
+    case 4: *speed = TiCloudStorageReplaySpeedX0_5; return YES;
+    case 0: *speed = TiCloudStorageReplaySpeedX1; return YES;
+    case 1: *speed = TiCloudStorageReplaySpeedX2; return YES;
+    case 2: *speed = TiCloudStorageReplaySpeedX4; return YES;
+    case 3: *speed = TiCloudStorageReplaySpeedX8; return YES;
+    default: return NO;
+  }
+}
+
+static NSString* TiRtcReactNativeCloudStorageAudioState(TiCloudStorageAudioOutputState state) {
+  switch (state) {
+    case TiCloudStorageAudioOutputStateIdle: return @"idle";
+    case TiCloudStorageAudioOutputStateBuffering: return @"buffering";
+    case TiCloudStorageAudioOutputStatePlaying: return @"playing";
+    case TiCloudStorageAudioOutputStateFailed: return @"failed";
+    case TiCloudStorageAudioOutputStatePaused: return @"paused";
+    case TiCloudStorageAudioOutputStateCompleted: return @"completed";
+  }
+  return @"failed";
+}
+
+static NSString* TiRtcReactNativeCloudStorageVideoState(TiCloudStorageVideoOutputState state) {
+  switch (state) {
+    case TiCloudStorageVideoOutputStateIdle: return @"idle";
+    case TiCloudStorageVideoOutputStateBuffering: return @"buffering";
+    case TiCloudStorageVideoOutputStateRendering: return @"rendering";
+    case TiCloudStorageVideoOutputStateFailed: return @"failed";
+    case TiCloudStorageVideoOutputStatePaused: return @"paused";
+    case TiCloudStorageVideoOutputStateCompleted: return @"completed";
+  }
+  return @"failed";
+}
+
+static NSDictionary* TiRtcReactNativeCloudStorageMp4Result(
+    TiRtcReactNativeRegistry* registry, TiCloudStorageRecordingResult* result) {
+  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),
+  };
+}
+
+@interface TiRtcReactNativeCloudStorageExportBridge : NSObject <TiRtcReactNativeReloadTask>
+@property(nonatomic, strong) TiCloudStorageExportTask* task;
+@property(nonatomic, assign) NSInteger objectId;
+- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry;
+- (void)complete:(TiCloudStorageRecordingResult*)result;
+- (void)await:(RCTPromiseResolveBlock)resolve;
+@end
+
+@implementation TiRtcReactNativeCloudStorageExportBridge {
+  TiRtcReactNativeRegistry* _registry;
+  TiCloudStorageRecordingResult* _result;
+  NSMutableArray<RCTPromiseResolveBlock>* _waiters;
+  BOOL _invalidated;
+  void (^_invalidationCompletion)(id file);
+}
+
+- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry {
+  if (self = [super init]) {
+    _registry = registry;
+    _waiters = [NSMutableArray new];
+  }
+  return self;
+}
+
+- (void)complete:(TiCloudStorageRecordingResult*)result {
+  NSArray<RCTPromiseResolveBlock>* waiters;
+  void (^invalidationCompletion)(id file);
+  @synchronized(self) {
+    if (_result != nil) return;
+    _result = result;
+    waiters = _invalidated ? @[] : [_waiters copy];
+    [_waiters removeAllObjects];
+    invalidationCompletion = _invalidationCompletion;
+    _invalidationCompletion = nil;
+  }
+  for (RCTPromiseResolveBlock resolve in waiters) {
+    resolve(TiRtcReactNativeCloudStorageMp4Result(_registry, result));
+  }
+  if (waiters.count > 0 && self.objectId > 0) [_registry releaseObject:self.objectId];
+  if (invalidationCompletion != nil) invalidationCompletion(result.file);
+}
+
+- (void)await:(RCTPromiseResolveBlock)resolve {
+  TiCloudStorageRecordingResult* result;
+  @synchronized(self) {
+    result = _result;
+    if (result == nil) {
+      [_waiters addObject:[resolve copy]];
+      return;
+    }
+  }
+  resolve(TiRtcReactNativeCloudStorageMp4Result(_registry, result));
+  if (self.objectId > 0) [_registry releaseObject:self.objectId];
+}
+
+- (void)stopForReactNativeInvalidation:(void (^)(id file))completion {
+  TiCloudStorageRecordingResult* result;
+  @synchronized(self) {
+    _invalidated = YES;
+    [_waiters removeAllObjects];
+    result = _result;
+    if (result == nil) _invalidationCompletion = [completion copy];
+  }
+  if (result != nil) {
+    completion(result.file);
+    return;
+  }
+  int32_t code = [self.task stop];
+  if (code != 0) {
+    @synchronized(self) {
+      _invalidationCompletion = nil;
+    }
+    completion(nil);
+  }
+}
+
+@end
+
+@implementation TiRtcReactNative (Storage)
+
+- (void)tiCloudStorageInitialize:(JS::NativeTiRtc::NativeInitOptions&)options
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  int32_t code = [TiCloudStorage initializeWithAppId:options.appId() ?: @""
+                                     endpoint:options.endpoint() ?: @""
+                            consoleLogEnabled:options.consoleLogEnabled()];
+  resolve(@(TiRtcReactNativeNormalizeDarwin(code)));
+}
+
+- (NSNumber*)tiCloudStorageShutdown {
+  return @(TiRtcReactNativeNormalizeDarwin([TiCloudStorage shutdown]));
+}
+
+- (NSDictionary*)tiCloudStorageCreate:(NSString*)token {
+  return [self
+      registerObject:^id { return [[TiCloudStorage alloc] initWithToken:token]; }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireCloudStorage:(TiCloudStorage*)object objectId:objectId];
+      }];
+}
+
+- (NSNumber*)tiCloudStorageUpdateToken:(double)objectId token:(NSString*)token {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiCloudStorage class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorage*)object updateToken:token]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (void)tiCloudStorageListRecordings:(double)objectId
+                 startTimeMs:(double)startTimeMs
+                   endTimeMs:(double)endTimeMs
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorage class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"recordings" : @[]});
+    return;
+  }
+  TiCloudStorage* cloudStorage = (TiCloudStorage*)object;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [cloudStorage listRecordingsWithStartTimeMs:(int64_t)startTimeMs
+                               endTimeMs:(int64_t)endTimeMs
+                               completion:^(TiCloudStorageRecordingRangesResult* result) {
+      NSMutableArray* ranges = [NSMutableArray arrayWithCapacity:result.recordings.count];
+      for (TiCloudStorageRecordingRange* range in result.recordings) {
+        [ranges addObject:@{@"startTimeMs" : @(range.startTimeMs), @"endTimeMs" : @(range.endTimeMs)}];
+      }
+      resolve(@{@"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)), @"recordings" : ranges});
+    }];
+  });
+}
+
+- (void)tiCloudStorageListRecordingDays:(double)objectId
+                     startDate:(NSString*)startDate
+                       endDate:(NSString*)endDate
+                    timeZoneId:(NSString*)timeZoneId
+                       resolve:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorage class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"days" : @[]});
+    return;
+  }
+  TiCloudStorage* cloudStorage = (TiCloudStorage*)object;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [cloudStorage listRecordingDaysWithStartDate:startDate
+                                  endDate:endDate
+                               timeZoneId:timeZoneId
+                               completion:^(TiCloudStorageRecordingDaysResult* result) {
+      NSMutableArray* days = [NSMutableArray arrayWithCapacity:result.days.count];
+      for (TiCloudStorageRecordingDay* day in result.days) {
+        [days addObject:@{@"date" : day.date, @"hasRecording" : @(day.hasRecording)}];
+      }
+      resolve(@{@"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)), @"days" : days});
+    }];
+  });
+}
+
+- (NSDictionary*)tiCloudStorageCreateReplay:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorage class]]) {
+    return TiRtcReactNativeCreateResult(TiRtcReactNativeErrorObjectReleased, 0, 0, nil);
+  }
+  return [self
+      registerObject:^id { return [(TiCloudStorage*)object createReplay]; }
+      wire:^id(NSInteger replayId, id replay) {
+        return [[self eventBinder] wireCloudStorageReplay:(TiCloudStorageReplay*)replay objectId:replayId];
+      }];
+}
+
+- (NSDictionary*)tiCloudStorageExportRecording:(double)objectId
+                           startTimeMs:(double)startTimeMs
+                             endTimeMs:(double)endTimeMs
+                        videoChannelId:(double)videoChannelId
+                        audioChannelId:(NSNumber*)audioChannelId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorage class]]) {
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull};
+  }
+  TiRtcReactNativeCloudStorageExportBridge* bridge =
+      [[TiRtcReactNativeCloudStorageExportBridge alloc] initWithRegistry:[self registry]];
+  TiCloudStorageExportRequest* request = [[TiCloudStorageExportRequest alloc]
+      initWithStartTimeMs:(int64_t)startTimeMs
+      endTimeMs:(int64_t)endTimeMs
+      videoChannelId:(NSInteger)videoChannelId
+      audioChannelId:audioChannelId];
+  TiCloudStorageExportTaskStartResult* started = [(TiCloudStorage*)object
+      exportRecording:request
+      progress:nil
+      completion:^(TiCloudStorageRecordingResult* result) { [bridge complete:result]; }];
+  if (started.code != 0 || started.task == nil) {
+    return @{@"code" : @(TiRtcReactNativeNormalizeDarwin(started.code)), @"taskId" : (id)kCFNull};
+  }
+  bridge.task = started.task;
+  bridge.objectId = [[self registry] addObject:bridge];
+  return @{@"code" : @0, @"taskId" : @(bridge.objectId)};
+}
+
+- (NSNumber*)tiCloudStorageExportProgress:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiRtcReactNativeCloudStorageExportBridge class]]
+             ? @(((TiRtcReactNativeCloudStorageExportBridge*)object).task.progress)
+             : @0;
+}
+
+- (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});
+    return;
+  }
+  [(TiRtcReactNativeCloudStorageExportBridge*)object await:resolve];
+}
+
+- (NSNumber*)tiCloudStorageExportStop:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiRtcReactNativeCloudStorageExportBridge class]]) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  TiCloudStorageExportTask* task = ((TiRtcReactNativeCloudStorageExportBridge*)object).task;
+  return @(TiRtcReactNativeNormalizeDarwin([task stop]));
+}
+
+- (NSNumber*)tiCloudStorageDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorage class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  int32_t code = [(TiCloudStorage*)object dispose];
+  if (code == 0) [[self registry] releaseObject:(NSInteger)objectId];
+  return @(TiRtcReactNativeNormalizeDarwin(code));
+}
+
+- (NSDictionary*)tiCloudStorageReplayGetInfo:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageReplay class]]) {
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"speed" : @0,
+             @"currentTimeMs" : (id)kCFNull};
+  }
+  TiCloudStorageReplay* replay = (TiCloudStorageReplay*)object;
+  return @{@"code" : @0, @"speed" : @(TiRtcReactNativeCloudStorageReplaySpeedValue(replay.speed)),
+           @"currentTimeMs" : replay.currentTimeMs ?: (id)kCFNull};
+}
+
+- (NSNumber*)tiCloudStorageReplayPlay:(double)objectId
+                  startTimeMs:(double)startTimeMs
+                    endTimeMs:(double)endTimeMs
+                initialTimeMs:(NSNumber*)initialTimeMs {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiCloudStorageReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageReplay*)object
+                   playWithStartTimeMs:(int64_t)startTimeMs
+                   endTimeMs:(int64_t)endTimeMs
+                   initialTimeMs:initialTimeMs]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)tiCloudStorageReplayPause:(double)objectId { return [self tiCloudStorageReplayCode:objectId selector:@selector(pause)]; }
+- (NSNumber*)tiCloudStorageReplayResume:(double)objectId { return [self tiCloudStorageReplayCode:objectId selector:@selector(resume)]; }
+- (NSNumber*)tiCloudStorageReplayStop:(double)objectId { return [self tiCloudStorageReplayCode:objectId selector:@selector(stop)]; }
+
+- (NSNumber*)tiCloudStorageReplaySeek:(double)objectId timeMs:(double)timeMs {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiCloudStorageReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageReplay*)object seekToTimeMs:(int64_t)timeMs]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)tiCloudStorageReplaySetSpeed:(double)objectId speed:(double)speed {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageReplay class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  TiCloudStorageReplaySpeed mapped;
+  if (!TiRtcReactNativeCloudStorageReplaySpeedFromValue((NSInteger)speed, &mapped)) return @(6000);
+  return @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageReplay*)object setSpeed:mapped]));
+}
+
+- (NSDictionary*)tiCloudStorageReplayStartRecording:(double)objectId
+                              videoChannelId:(double)videoChannelId
+                              audioChannelId:(NSNumber*)audioChannelId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageReplay class]]) {
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull};
+  }
+  TiCloudStorageRecordingTaskStartResult* started = [(TiCloudStorageReplay*)object
+      startRecordingWithVideoChannelId:(NSInteger)videoChannelId audioChannelId:audioChannelId];
+  if (started.code != 0 || started.task == nil) {
+    return @{@"code" : @(TiRtcReactNativeNormalizeDarwin(started.code)), @"taskId" : (id)kCFNull};
+  }
+  NSInteger taskId = [[self registry] addObject:started.task];
+  return @{@"code" : @0, @"taskId" : @(taskId)};
+}
+
+- (void)tiCloudStorageRecordingTaskStop:(double)objectId
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageRecordingTask class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"fileId" : (id)kCFNull,
+              @"filePath" : (id)kCFNull, @"durationMs" : (id)kCFNull});
+    return;
+  }
+  [(TiCloudStorageRecordingTask*)object stopWithCompletion:^(TiCloudStorageRecordingResult* result) {
+    [[self registry] releaseObject:(NSInteger)objectId];
+    resolve(TiRtcReactNativeCloudStorageMp4Result([self registry], result));
+  }];
+}
+
+- (NSNumber*)tiCloudStorageReplayDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageReplay class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  int32_t code = [(TiCloudStorageReplay*)object dispose];
+  if (code == 0) [[self registry] releaseObject:(NSInteger)objectId];
+  return @(TiRtcReactNativeNormalizeDarwin(code));
+}
+
+- (NSNumber*)tiCloudStorageReplayCode:(double)objectId selector:(SEL)selector {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageReplay class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  IMP implementation = [object methodForSelector:selector];
+  int32_t (*call)(id, SEL) = (int32_t (*)(id, SEL))implementation;
+  return @(TiRtcReactNativeNormalizeDarwin(call(object, selector)));
+}
+
+- (NSDictionary*)tiCloudStorageCreateAudioOutput {
+  return [self
+      registerObject:^id { return [TiCloudStorageAudioOutput new]; }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireCloudStorageAudioOutput:(TiCloudStorageAudioOutput*)object objectId:objectId];
+      }];
+}
+
+- (NSDictionary*)tiCloudStorageAudioOutputGetState:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageAudioOutput class]]) {
+    return TiRtcReactNativeStateResult(TiRtcReactNativeErrorObjectReleased, nil);
+  }
+  return TiRtcReactNativeStateResult(0, TiRtcReactNativeCloudStorageAudioState(((TiCloudStorageAudioOutput*)object).state));
+}
+
+- (NSNumber*)tiCloudStorageAudioOutputSetVolume:(double)objectId volumePercent:(double)volumePercent {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiCloudStorageAudioOutput class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageAudioOutput*)object setVolume:(uint32_t)volumePercent]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)tiCloudStorageAudioOutputAttach:(double)outputId replayId:(double)replayId channelId:(double)channelId {
+  id output = [[self registry] objectForId:(NSInteger)outputId];
+  id replay = [[self registry] objectForId:(NSInteger)replayId];
+  return [output isKindOfClass:[TiCloudStorageAudioOutput class]] && [replay isKindOfClass:[TiCloudStorageReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageAudioOutput*)output
+                   attachWithReplay:(TiCloudStorageReplay*)replay channelId:(uint8_t)channelId]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)tiCloudStorageAudioOutputDetach:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiCloudStorageAudioOutput class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageAudioOutput*)object detach]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)tiCloudStorageAudioOutputDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageAudioOutput class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  int32_t code = [(TiCloudStorageAudioOutput*)object dispose];
+  if (code == 0) [[self registry] releaseObject:(NSInteger)objectId];
+  return @(TiRtcReactNativeNormalizeDarwin(code));
+}
+
+- (NSDictionary*)tiCloudStorageCreateVideoOutput {
+  return [self
+      registerObject:^id { return [TiCloudStorageVideoOutput new]; }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireCloudStorageVideoOutput:(TiCloudStorageVideoOutput*)object objectId:objectId];
+      }];
+}
+
+- (NSDictionary*)tiCloudStorageVideoOutputGetState:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageVideoOutput class]]) {
+    return TiRtcReactNativeStateResult(TiRtcReactNativeErrorObjectReleased, nil);
+  }
+  return TiRtcReactNativeStateResult(0, TiRtcReactNativeCloudStorageVideoState(((TiCloudStorageVideoOutput*)object).state));
+}
+
+- (NSNumber*)tiCloudStorageVideoOutputAttach:(double)outputId replayId:(double)replayId channelId:(double)channelId {
+  id output = [[self registry] objectForId:(NSInteger)outputId];
+  id replay = [[self registry] objectForId:(NSInteger)replayId];
+  return [output isKindOfClass:[TiCloudStorageVideoOutput class]] && [replay isKindOfClass:[TiCloudStorageReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageVideoOutput*)output
+                   attachWithReplay:(TiCloudStorageReplay*)replay channelId:(uint8_t)channelId]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)tiCloudStorageVideoOutputDetach:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiCloudStorageVideoOutput class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiCloudStorageVideoOutput*)object detach]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (void)tiCloudStorageVideoOutputTakeSnapshot:(double)objectId
+                              resolve:(RCTPromiseResolveBlock)resolve
+                               reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageVideoOutput class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"fileId" : (id)kCFNull,
+              @"filePath" : (id)kCFNull});
+    return;
+  }
+  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});
+    }];
+  });
+}
+
+- (NSNumber*)tiCloudStorageVideoOutputDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiCloudStorageVideoOutput class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  TiCloudStorageVideoOutput* output = (TiCloudStorageVideoOutput*)object;
+  int32_t code = TiRtcReactNativeDetachCloudStorageVideoView(output);
+  if (code == 0) code = [output dispose];
+  if (code == 0) [[self registry] releaseObject:(NSInteger)objectId];
+  return @(TiRtcReactNativeNormalizeDarwin(code));
+}
+
+@end
+#pragma clang diagnostic pop

package/ios/TiRtcReactNative.h

@@ -1,6 +1,7 @@
 #import <Foundation/Foundation.h>
+#import <React/RCTInvalidating.h>
 
 #import "TiRtcSpec.h"
 
-@interface TiRtcReactNative : NativeTiRtcSpecBase <NativeTiRtcSpec>
+@interface TiRtcReactNative : NativeTiRtcSpecBase <NativeTiRtcSpec, RCTInvalidating>
 @end