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

package/ios/TiRtcReactNative+Store.mm

@@ -0,0 +1,496 @@
+#import "TiRtcReactNative+Private.h"
+
+#import "TiRtcReactNativeErrors.h"
+#import "TiRtcReactNativeMaps.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"
+
+static NSInteger TiRtcReactNativeStoreReplaySpeedValue(TiStoreReplaySpeed speed) {
+  switch (speed) {
+    case TiStoreReplaySpeedX1: return 0;
+    case TiStoreReplaySpeedX2: return 1;
+    case TiStoreReplaySpeedX4: return 2;
+    case TiStoreReplaySpeedX8: return 3;
+  }
+  return 0;
+}
+
+static BOOL TiRtcReactNativeStoreReplaySpeedFromValue(NSInteger value, TiStoreReplaySpeed* speed) {
+  switch (value) {
+    case 0: *speed = TiStoreReplaySpeedX1; return YES;
+    case 1: *speed = TiStoreReplaySpeedX2; return YES;
+    case 2: *speed = TiStoreReplaySpeedX4; return YES;
+    case 3: *speed = TiStoreReplaySpeedX8; return YES;
+    default: return NO;
+  }
+}
+
+static NSString* TiRtcReactNativeStoreAudioState(TiStoreAudioOutputState state) {
+  switch (state) {
+    case TiStoreAudioOutputStateIdle: return @"idle";
+    case TiStoreAudioOutputStateBuffering: return @"buffering";
+    case TiStoreAudioOutputStatePlaying: return @"playing";
+    case TiStoreAudioOutputStateFailed: return @"failed";
+    case TiStoreAudioOutputStatePaused: return @"paused";
+    case TiStoreAudioOutputStateCompleted: return @"completed";
+  }
+  return @"failed";
+}
+
+static NSString* TiRtcReactNativeStoreVideoState(TiStoreVideoOutputState state) {
+  switch (state) {
+    case TiStoreVideoOutputStateIdle: return @"idle";
+    case TiStoreVideoOutputStateBuffering: return @"buffering";
+    case TiStoreVideoOutputStateRendering: return @"rendering";
+    case TiStoreVideoOutputStateFailed: return @"failed";
+    case TiStoreVideoOutputStatePaused: return @"paused";
+    case TiStoreVideoOutputStateCompleted: return @"completed";
+  }
+  return @"failed";
+}
+
+static NSDictionary* TiRtcReactNativeStoreMp4Result(
+    TiRtcReactNativeRegistry* registry, TiStoreRecordingResult* 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 TiRtcReactNativeStoreExportBridge : NSObject <TiRtcReactNativeReloadTask>
+@property(nonatomic, strong) TiStoreExportTask* task;
+@property(nonatomic, assign) NSInteger objectId;
+- (instancetype)initWithRegistry:(TiRtcReactNativeRegistry*)registry;
+- (void)complete:(TiStoreRecordingResult*)result;
+- (void)await:(RCTPromiseResolveBlock)resolve;
+@end
+
+@implementation TiRtcReactNativeStoreExportBridge {
+  TiRtcReactNativeRegistry* _registry;
+  TiStoreRecordingResult* _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:(TiStoreRecordingResult*)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(TiRtcReactNativeStoreMp4Result(_registry, result));
+  }
+  if (waiters.count > 0 && self.objectId > 0) [_registry releaseObject:self.objectId];
+  if (invalidationCompletion != nil) invalidationCompletion(result.file);
+}
+
+- (void)await:(RCTPromiseResolveBlock)resolve {
+  TiStoreRecordingResult* result;
+  @synchronized(self) {
+    result = _result;
+    if (result == nil) {
+      [_waiters addObject:[resolve copy]];
+      return;
+    }
+  }
+  resolve(TiRtcReactNativeStoreMp4Result(_registry, result));
+  if (self.objectId > 0) [_registry releaseObject:self.objectId];
+}
+
+- (void)stopForReactNativeInvalidation:(void (^)(id file))completion {
+  TiStoreRecordingResult* 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 (Store)
+
+- (void)storeInitialize:(JS::NativeTiRtc::NativeInitOptions&)options
+                 resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject {
+  int32_t code = [TiStore initializeWithAppId:options.appId() ?: @""
+                                     endpoint:options.endpoint() ?: @""
+                            consoleLogEnabled:options.consoleLogEnabled()];
+  resolve(@(TiRtcReactNativeNormalizeDarwin(code)));
+}
+
+- (NSNumber*)storeShutdown {
+  return @(TiRtcReactNativeNormalizeDarwin([TiStore shutdown]));
+}
+
+- (NSDictionary*)storeCreate:(NSString*)token {
+  return [self
+      registerObject:^id { return [[TiStore alloc] initWithToken:token]; }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireStore:(TiStore*)object objectId:objectId];
+      }];
+}
+
+- (NSNumber*)storeUpdateToken:(double)objectId token:(NSString*)token {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiStore class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStore*)object updateToken:token]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (void)storeListRecordings:(double)objectId
+                 startTimeMs:(double)startTimeMs
+                   endTimeMs:(double)endTimeMs
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStore class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"recordings" : @[]});
+    return;
+  }
+  TiStore* store = (TiStore*)object;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [store listRecordingsWithStartTimeMs:(int64_t)startTimeMs
+                               endTimeMs:(int64_t)endTimeMs
+                               completion:^(TiStoreRecordingRangesResult* result) {
+      NSMutableArray* ranges = [NSMutableArray arrayWithCapacity:result.recordings.count];
+      for (TiStoreRecordingRange* range in result.recordings) {
+        [ranges addObject:@{@"startTimeMs" : @(range.startTimeMs), @"endTimeMs" : @(range.endTimeMs)}];
+      }
+      resolve(@{@"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)), @"recordings" : ranges});
+    }];
+  });
+}
+
+- (void)storeListRecordingDays:(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:[TiStore class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"days" : @[]});
+    return;
+  }
+  TiStore* store = (TiStore*)object;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [store listRecordingDaysWithStartDate:startDate
+                                  endDate:endDate
+                               timeZoneId:timeZoneId
+                               completion:^(TiStoreRecordingDaysResult* result) {
+      NSMutableArray* days = [NSMutableArray arrayWithCapacity:result.days.count];
+      for (TiStoreRecordingDay* day in result.days) {
+        [days addObject:@{@"date" : day.date, @"hasRecording" : @(day.hasRecording)}];
+      }
+      resolve(@{@"code" : @(TiRtcReactNativeNormalizeDarwin(result.code)), @"days" : days});
+    }];
+  });
+}
+
+- (NSDictionary*)storeCreateReplay:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStore class]]) {
+    return TiRtcReactNativeCreateResult(TiRtcReactNativeErrorObjectReleased, 0, 0, nil);
+  }
+  return [self
+      registerObject:^id { return [(TiStore*)object createReplay]; }
+      wire:^id(NSInteger replayId, id replay) {
+        return [[self eventBinder] wireStoreReplay:(TiStoreReplay*)replay objectId:replayId];
+      }];
+}
+
+- (NSDictionary*)storeExportRecording:(double)objectId
+                           startTimeMs:(double)startTimeMs
+                             endTimeMs:(double)endTimeMs
+                        videoChannelId:(double)videoChannelId
+                        audioChannelId:(NSNumber*)audioChannelId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStore class]]) {
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull};
+  }
+  TiRtcReactNativeStoreExportBridge* bridge =
+      [[TiRtcReactNativeStoreExportBridge alloc] initWithRegistry:[self registry]];
+  TiStoreExportRequest* request = [[TiStoreExportRequest alloc]
+      initWithStartTimeMs:(int64_t)startTimeMs
+      endTimeMs:(int64_t)endTimeMs
+      videoChannelId:(NSInteger)videoChannelId
+      audioChannelId:audioChannelId];
+  TiStoreExportTaskStartResult* started = [(TiStore*)object
+      exportRecording:request
+      progress:nil
+      completion:^(TiStoreRecordingResult* 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*)storeExportProgress:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiRtcReactNativeStoreExportBridge class]]
+             ? @(((TiRtcReactNativeStoreExportBridge*)object).task.progress)
+             : @0;
+}
+
+- (void)storeExportResult:(double)objectId
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiRtcReactNativeStoreExportBridge class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"fileId" : (id)kCFNull,
+              @"filePath" : (id)kCFNull, @"durationMs" : (id)kCFNull});
+    return;
+  }
+  [(TiRtcReactNativeStoreExportBridge*)object await:resolve];
+}
+
+- (NSNumber*)storeExportStop:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiRtcReactNativeStoreExportBridge class]]) {
+    return @(TiRtcReactNativeErrorObjectReleased);
+  }
+  TiStoreExportTask* task = ((TiRtcReactNativeStoreExportBridge*)object).task;
+  return @(TiRtcReactNativeNormalizeDarwin([task stop]));
+}
+
+- (NSNumber*)storeDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStore class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  int32_t code = [(TiStore*)object dispose];
+  if (code == 0) [[self registry] releaseObject:(NSInteger)objectId];
+  return @(TiRtcReactNativeNormalizeDarwin(code));
+}
+
+- (NSDictionary*)storeReplayGetInfo:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreReplay class]]) {
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"speed" : @0,
+             @"currentTimeMs" : (id)kCFNull};
+  }
+  TiStoreReplay* replay = (TiStoreReplay*)object;
+  return @{@"code" : @0, @"speed" : @(TiRtcReactNativeStoreReplaySpeedValue(replay.speed)),
+           @"currentTimeMs" : replay.currentTimeMs ?: (id)kCFNull};
+}
+
+- (NSNumber*)storeReplayPlay:(double)objectId
+                  startTimeMs:(double)startTimeMs
+                    endTimeMs:(double)endTimeMs
+                initialTimeMs:(NSNumber*)initialTimeMs {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiStoreReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStoreReplay*)object
+                   playWithStartTimeMs:(int64_t)startTimeMs
+                   endTimeMs:(int64_t)endTimeMs
+                   initialTimeMs:initialTimeMs]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)storeReplayPause:(double)objectId { return [self storeReplayCode:objectId selector:@selector(pause)]; }
+- (NSNumber*)storeReplayResume:(double)objectId { return [self storeReplayCode:objectId selector:@selector(resume)]; }
+- (NSNumber*)storeReplayStop:(double)objectId { return [self storeReplayCode:objectId selector:@selector(stop)]; }
+
+- (NSNumber*)storeReplaySeek:(double)objectId timeMs:(double)timeMs {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiStoreReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStoreReplay*)object seekToTimeMs:(int64_t)timeMs]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)storeReplaySetSpeed:(double)objectId speed:(double)speed {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreReplay class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  TiStoreReplaySpeed mapped;
+  if (!TiRtcReactNativeStoreReplaySpeedFromValue((NSInteger)speed, &mapped)) return @(6000);
+  return @(TiRtcReactNativeNormalizeDarwin([(TiStoreReplay*)object setSpeed:mapped]));
+}
+
+- (NSDictionary*)storeReplayStartRecording:(double)objectId
+                              videoChannelId:(double)videoChannelId
+                              audioChannelId:(NSNumber*)audioChannelId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreReplay class]]) {
+    return @{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"taskId" : (id)kCFNull};
+  }
+  TiStoreRecordingTaskStartResult* started = [(TiStoreReplay*)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)storeRecordingTaskStop:(double)objectId
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreRecordingTask class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"fileId" : (id)kCFNull,
+              @"filePath" : (id)kCFNull, @"durationMs" : (id)kCFNull});
+    return;
+  }
+  [(TiStoreRecordingTask*)object stopWithCompletion:^(TiStoreRecordingResult* result) {
+    [[self registry] releaseObject:(NSInteger)objectId];
+    resolve(TiRtcReactNativeStoreMp4Result([self registry], result));
+  }];
+}
+
+- (NSNumber*)storeReplayDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreReplay class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  int32_t code = [(TiStoreReplay*)object dispose];
+  if (code == 0) [[self registry] releaseObject:(NSInteger)objectId];
+  return @(TiRtcReactNativeNormalizeDarwin(code));
+}
+
+- (NSNumber*)storeReplayCode:(double)objectId selector:(SEL)selector {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreReplay class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  IMP implementation = [object methodForSelector:selector];
+  int32_t (*call)(id, SEL) = (int32_t (*)(id, SEL))implementation;
+  return @(TiRtcReactNativeNormalizeDarwin(call(object, selector)));
+}
+
+- (NSDictionary*)storeCreateAudioOutput {
+  return [self
+      registerObject:^id { return [TiStoreAudioOutput new]; }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireStoreAudioOutput:(TiStoreAudioOutput*)object objectId:objectId];
+      }];
+}
+
+- (NSDictionary*)storeAudioOutputGetState:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreAudioOutput class]]) {
+    return TiRtcReactNativeStateResult(TiRtcReactNativeErrorObjectReleased, nil);
+  }
+  return TiRtcReactNativeStateResult(0, TiRtcReactNativeStoreAudioState(((TiStoreAudioOutput*)object).state));
+}
+
+- (NSNumber*)storeAudioOutputSetVolume:(double)objectId volumePercent:(double)volumePercent {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiStoreAudioOutput class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStoreAudioOutput*)object setVolume:(uint32_t)volumePercent]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)storeAudioOutputAttach:(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:[TiStoreAudioOutput class]] && [replay isKindOfClass:[TiStoreReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStoreAudioOutput*)output
+                   attachWithReplay:(TiStoreReplay*)replay channelId:(uint8_t)channelId]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)storeAudioOutputDetach:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiStoreAudioOutput class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStoreAudioOutput*)object detach]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)storeAudioOutputDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreAudioOutput class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  int32_t code = [(TiStoreAudioOutput*)object dispose];
+  if (code == 0) [[self registry] releaseObject:(NSInteger)objectId];
+  return @(TiRtcReactNativeNormalizeDarwin(code));
+}
+
+- (NSDictionary*)storeCreateVideoOutput {
+  return [self
+      registerObject:^id { return [TiStoreVideoOutput new]; }
+      wire:^id(NSInteger objectId, id object) {
+        return [[self eventBinder] wireStoreVideoOutput:(TiStoreVideoOutput*)object objectId:objectId];
+      }];
+}
+
+- (NSDictionary*)storeVideoOutputGetState:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreVideoOutput class]]) {
+    return TiRtcReactNativeStateResult(TiRtcReactNativeErrorObjectReleased, nil);
+  }
+  return TiRtcReactNativeStateResult(0, TiRtcReactNativeStoreVideoState(((TiStoreVideoOutput*)object).state));
+}
+
+- (NSNumber*)storeVideoOutputAttach:(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:[TiStoreVideoOutput class]] && [replay isKindOfClass:[TiStoreReplay class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStoreVideoOutput*)output
+                   attachWithReplay:(TiStoreReplay*)replay channelId:(uint8_t)channelId]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (NSNumber*)storeVideoOutputDetach:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  return [object isKindOfClass:[TiStoreVideoOutput class]]
+             ? @(TiRtcReactNativeNormalizeDarwin([(TiStoreVideoOutput*)object detach]))
+             : @(TiRtcReactNativeErrorObjectReleased);
+}
+
+- (void)storeVideoOutputTakeSnapshot:(double)objectId
+                              resolve:(RCTPromiseResolveBlock)resolve
+                               reject:(RCTPromiseRejectBlock)reject {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreVideoOutput class]]) {
+    resolve(@{@"code" : @(TiRtcReactNativeErrorObjectReleased), @"fileId" : (id)kCFNull,
+              @"filePath" : (id)kCFNull});
+    return;
+  }
+  TiStoreVideoOutput* output = (TiStoreVideoOutput*)object;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [output takeSnapshotWithCompletion:^(TiStoreSnapshotResult* 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*)storeVideoOutputDispose:(double)objectId {
+  id object = [[self registry] objectForId:(NSInteger)objectId];
+  if (![object isKindOfClass:[TiStoreVideoOutput class]]) return @(TiRtcReactNativeErrorObjectReleased);
+  int32_t code = [(TiStoreVideoOutput*)object 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

package/ios/TiRtcReactNative.mm

@@ -1,7 +1,9 @@
 #import "TiRtcReactNative.h"
+#import "TiRtcReactNative+Private.h"
 
 #import <React/RCTBridgeModule.h>
 
+#import <atomic>
 #import <memory>
 
 #import "TiRtcReactNativeErrors.h"
@@ -12,23 +14,51 @@
 #import "TiRtcReactNativeOptions.h"
 #import "TiRtcReactNativeRegistry.h"
 
+@protocol TiRtcReactNativeMediaFile <NSObject>
+- (void)deleteWithCompletion:(void (^)(int32_t code))completion;
+@end
+
+static void TiRtcReactNativeLogInvalidationFailure(NSString* operation, int32_t code) {
+  if (code == 0 || code == TiRtcReactNativeErrorObjectReleased) return;
+  [TiRtcLogging logWithLevel:TiRtcLogLevelWarning
+                         tag:@"TIRTC_REACT_NATIVE"
+                     message:[NSString stringWithFormat:
+                                           @"[module_invalidate] operation=%@ error_code=%d",
+                                           operation, code]];
+}
+
+static void TiRtcReactNativeDeleteForInvalidation(id file, dispatch_group_t group) {
+  if (file == nil || ![file respondsToSelector:@selector(deleteWithCompletion:)]) return;
+  dispatch_group_enter(group);
+  [(id<TiRtcReactNativeMediaFile>)file deleteWithCompletion:^(int32_t code) {
+    TiRtcReactNativeLogInvalidationFailure(@"media_delete", code);
+    dispatch_group_leave(group);
+  }];
+}
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wprotocol"
 @implementation TiRtcReactNative {
   TiRtcReactNativeRegistry* _registry;
   TiRtcReactNativeEventSink* _eventSink;
   TiRtcReactNativeEventBinder* _eventBinder;
+  std::atomic_bool _invalidated;
 }
 
 RCT_EXPORT_MODULE(TiRtc)
 
 - (instancetype)init {
   if (self = [super init]) {
+    _invalidated.store(false);
     _registry = [TiRtcReactNativeRegistry sharedRegistry];
     __weak TiRtcReactNative* weakSelf = self;
     _eventSink = [[TiRtcReactNativeEventSink alloc] initWithRegistry:_registry
                                                            emitBlock:^(NSDictionary* event) {
-                                                             [weakSelf emitOnTiRtcEvent:event];
+                                                             TiRtcReactNative* strongSelf = weakSelf;
+                                                             if (strongSelf != nil &&
+                                                                 !strongSelf->_invalidated.load()) {
+                                                               [strongSelf emitOnTiRtcEvent:event];
+                                                             }
                                                            }];
     [_registry setEventSink:_eventSink];
     _eventBinder = [[TiRtcReactNativeEventBinder alloc] initWithEventSink:_eventSink];
@@ -36,6 +66,84 @@ RCT_EXPORT_MODULE(TiRtc)
   return self;
 }
 
+- (void)invalidate {
+  if (_invalidated.exchange(true)) return;
+  NSArray* objects = [_registry drainObjects];
+  NSArray* files = [_registry drainTransientObjects];
+  dispatch_group_t pending = dispatch_group_create();
+  for (id file in files) TiRtcReactNativeDeleteForInvalidation(file, pending);
+  for (id object in objects) {
+    if ([object isKindOfClass:[TiRtcRecordingTask class]]) {
+      dispatch_group_enter(pending);
+      [(TiRtcRecordingTask*)object stopWithCompletion:^(TiRtcRecordingResult* result) {
+        TiRtcReactNativeDeleteForInvalidation(result.file, pending);
+        dispatch_group_leave(pending);
+      }];
+    } else if ([object isKindOfClass:[TiStoreRecordingTask class]]) {
+      dispatch_group_enter(pending);
+      [(TiStoreRecordingTask*)object stopWithCompletion:^(TiStoreRecordingResult* result) {
+        TiRtcReactNativeDeleteForInvalidation(result.file, pending);
+        dispatch_group_leave(pending);
+      }];
+    } else if ([object conformsToProtocol:@protocol(TiRtcReactNativeReloadTask)]) {
+      dispatch_group_enter(pending);
+      [(id<TiRtcReactNativeReloadTask>)object
+          stopForReactNativeInvalidation:^(id file) {
+            TiRtcReactNativeDeleteForInvalidation(file, pending);
+            dispatch_group_leave(pending);
+          }];
+    }
+  }
+  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 (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 (TiRtcAudioOutput* output in objects) {
+      if ([output isKindOfClass:[TiRtcAudioOutput class]])
+        TiRtcReactNativeLogInvalidationFailure(@"audio_output_dispose", [output dispose]);
+    }
+    for (TiRtcVideoOutput* output in objects) {
+      if ([output isKindOfClass:[TiRtcVideoOutput class]])
+        TiRtcReactNativeLogInvalidationFailure(@"video_output_dispose", [output dispose]);
+    }
+    for (TiRtcAudioInput* input in objects) {
+      if ([input isKindOfClass:[TiRtcAudioInput class]])
+        TiRtcReactNativeLogInvalidationFailure(@"audio_input_dispose", [input dispose]);
+    }
+    for (TiRtcVideoInput* input in objects) {
+      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 (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]);
+    }
+    TiRtcReactNativeLogInvalidationFailure(@"store_shutdown", [TiStore shutdown]);
+    TiRtcReactNativeLogInvalidationFailure(@"runtime_shutdown", [TiRtc shutdown]);
+    [TiRtcLogging logWithLevel:TiRtcLogLevelInfo
+                           tag:@"TIRTC_REACT_NATIVE"
+                       message:@"[module_invalidate] native owners released"];
+  });
+}
+
 - (void)initialize:(JS::NativeTiRtc::NativeInitOptions&)options
            resolve:(RCTPromiseResolveBlock)resolve
             reject:(RCTPromiseRejectBlock)reject {

package/ios/TiRtcReactNativeEventBinder.h

@@ -6,6 +6,10 @@
 @class TiRtcReactNativeEventSink;
 @class TiRtcVideoInput;
 @class TiRtcVideoOutput;
+@class TiStore;
+@class TiStoreAudioOutput;
+@class TiStoreReplay;
+@class TiStoreVideoOutput;
 
 @interface TiRtcReactNativeEventBinder : NSObject
 
@@ -15,5 +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;
 
 @end