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

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.mm

@@ -79,9 +79,9 @@ RCT_EXPORT_MODULE(TiRtc)
         TiRtcReactNativeDeleteForInvalidation(result.file, pending);
         dispatch_group_leave(pending);
       }];
-    } else if ([object isKindOfClass:[TiStoreRecordingTask class]]) {
+    } else if ([object isKindOfClass:[TiCloudStorageRecordingTask class]]) {
       dispatch_group_enter(pending);
-      [(TiStoreRecordingTask*)object stopWithCompletion:^(TiStoreRecordingResult* result) {
+      [(TiCloudStorageRecordingTask*)object stopWithCompletion:^(TiCloudStorageRecordingResult* result) {
         TiRtcReactNativeDeleteForInvalidation(result.file, pending);
         dispatch_group_leave(pending);
       }];
@@ -95,16 +95,16 @@ RCT_EXPORT_MODULE(TiRtc)
     }
   }
   dispatch_group_notify(pending, dispatch_get_main_queue(), ^{
-    for (TiStoreAudioOutput* output in objects) {
-      if (![output isKindOfClass:[TiStoreAudioOutput class]]) continue;
-      TiRtcReactNativeLogInvalidationFailure(@"store_audio_detach", [output detach]);
-      TiRtcReactNativeLogInvalidationFailure(@"store_audio_dispose", [output dispose]);
+    for (TiCloudStorageAudioOutput* output in objects) {
+      if (![output isKindOfClass:[TiCloudStorageAudioOutput class]]) continue;
+      TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-audio-detach", [output detach]);
+      TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-audio-dispose", [output dispose]);
     }
-    for (TiStoreVideoOutput* output in objects) {
-      if (![output isKindOfClass:[TiStoreVideoOutput class]]) continue;
-      TiRtcReactNativeLogInvalidationFailure(@"store_video_detach", [output detach]);
-      TiRtcReactNativeLogInvalidationFailure(@"store_video_view_detach", [output detachView]);
-      TiRtcReactNativeLogInvalidationFailure(@"store_video_dispose", [output dispose]);
+    for (TiCloudStorageVideoOutput* output in objects) {
+      if (![output isKindOfClass:[TiCloudStorageVideoOutput class]]) continue;
+      TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-video-detach", [output detach]);
+      TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-video-view-detach", [output detachView]);
+      TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-video-dispose", [output dispose]);
     }
     for (TiRtcAudioOutput* output in objects) {
       if ([output isKindOfClass:[TiRtcAudioOutput class]])
@@ -122,21 +122,21 @@ RCT_EXPORT_MODULE(TiRtc)
       if ([input isKindOfClass:[TiRtcVideoInput class]])
         TiRtcReactNativeLogInvalidationFailure(@"video_input_dispose", [input dispose]);
     }
-    for (TiStoreReplay* replay in objects) {
-      if (![replay isKindOfClass:[TiStoreReplay class]]) continue;
-      TiRtcReactNativeLogInvalidationFailure(@"store_replay_stop", [replay stop]);
-      TiRtcReactNativeLogInvalidationFailure(@"store_replay_dispose", [replay dispose]);
+    for (TiCloudStorageReplay* replay in objects) {
+      if (![replay isKindOfClass:[TiCloudStorageReplay class]]) continue;
+      TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-replay-stop", [replay stop]);
+      TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-replay-dispose", [replay dispose]);
     }
     for (TiRtcConn* conn in objects) {
       if (![conn isKindOfClass:[TiRtcConn class]]) continue;
       TiRtcReactNativeLogInvalidationFailure(@"conn_disconnect", [conn disconnect]);
       TiRtcReactNativeLogInvalidationFailure(@"conn_dispose", [conn dispose]);
     }
-    for (TiStore* store in objects) {
-      if ([store isKindOfClass:[TiStore class]])
-        TiRtcReactNativeLogInvalidationFailure(@"store_dispose", [store dispose]);
+    for (TiCloudStorage* cloudStorage in objects) {
+      if ([cloudStorage isKindOfClass:[TiCloudStorage class]])
+        TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-dispose", [cloudStorage dispose]);
     }
-    TiRtcReactNativeLogInvalidationFailure(@"store_shutdown", [TiStore shutdown]);
+    TiRtcReactNativeLogInvalidationFailure(@"ti-cloud-storage-shutdown", [TiCloudStorage shutdown]);
     TiRtcReactNativeLogInvalidationFailure(@"runtime_shutdown", [TiRtc shutdown]);
     [TiRtcLogging logWithLevel:TiRtcLogLevelInfo
                            tag:@"TIRTC_REACT_NATIVE"

package/ios/TiRtcReactNativeEventBinder.h

@@ -6,10 +6,10 @@
 @class TiRtcReactNativeEventSink;
 @class TiRtcVideoInput;
 @class TiRtcVideoOutput;
-@class TiStore;
-@class TiStoreAudioOutput;
-@class TiStoreReplay;
-@class TiStoreVideoOutput;
+@class TiCloudStorage;
+@class TiCloudStorageAudioOutput;
+@class TiCloudStorageReplay;
+@class TiCloudStorageVideoOutput;
 
 @interface TiRtcReactNativeEventBinder : NSObject
 
@@ -19,9 +19,9 @@
 - (id)wireVideoOutput:(TiRtcVideoOutput*)output objectId:(NSInteger)objectId;
 - (id)wireAudioInput:(TiRtcAudioInput*)input objectId:(NSInteger)objectId;
 - (id)wireVideoInput:(TiRtcVideoInput*)input objectId:(NSInteger)objectId;
-- (id)wireStore:(TiStore*)store objectId:(NSInteger)objectId;
-- (id)wireStoreReplay:(TiStoreReplay*)replay objectId:(NSInteger)objectId;
-- (id)wireStoreAudioOutput:(TiStoreAudioOutput*)output objectId:(NSInteger)objectId;
-- (id)wireStoreVideoOutput:(TiStoreVideoOutput*)output objectId:(NSInteger)objectId;
+- (id)wireCloudStorage:(TiCloudStorage*)cloudStorage objectId:(NSInteger)objectId;
+- (id)wireCloudStorageReplay:(TiCloudStorageReplay*)replay objectId:(NSInteger)objectId;
+- (id)wireCloudStorageAudioOutput:(TiCloudStorageAudioOutput*)output objectId:(NSInteger)objectId;
+- (id)wireCloudStorageVideoOutput:(TiCloudStorageVideoOutput*)output objectId:(NSInteger)objectId;
 
 @end