react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/ios/REANodesManager.mm

@@ -0,0 +1,517 @@
+#import <RNReanimated/REAModule.h>
+#import <RNReanimated/REANodesManager.h>
+#import <React/RCTConvert.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTComponentViewRegistry.h>
+#import <React/RCTMountingManager.h>
+#import <React/RCTSurfacePresenter.h>
+#import <react/renderer/core/ShadowNode.h>
+#import <react/renderer/uimanager/UIManager.h>
+#else
+#import <stdatomic.h>
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+using namespace facebook::react;
+#endif
+
+// Interface below has been added in order to use private methods of RCTUIManager,
+// RCTUIManager#UpdateView is a React Method which is exported to JS but in
+// Objective-C it stays private
+// RCTUIManager#setNeedsLayout is a method which updated layout only which
+// in its turn will trigger relayout if no batch has been activated
+
+@interface RCTUIManager ()
+
+- (void)updateView:(nonnull NSNumber *)reactTag viewName:(NSString *)viewName props:(NSDictionary *)props;
+
+- (void)setNeedsLayout;
+
+@end
+
+@interface RCTUIManager (SyncUpdates)
+
+- (BOOL)hasEnqueuedUICommands;
+
+- (void)runSyncUIUpdatesWithObserver:(id<RCTUIManagerObserver>)observer;
+
+@end
+
+@interface ComponentUpdate : NSObject
+
+@property (nonnull) NSMutableDictionary *props;
+@property (nonnull) NSNumber *viewTag;
+@property (nonnull) NSString *viewName;
+
+@end
+
+@implementation ComponentUpdate
+@end
+
+@implementation RCTUIManager (SyncUpdates)
+
+- (BOOL)hasEnqueuedUICommands
+{
+  // Accessing some private bits of RCTUIManager to provide missing functionality
+  return [[self valueForKey:@"_pendingUIBlocks"] count] > 0;
+}
+
+- (void)runSyncUIUpdatesWithObserver:(id<RCTUIManagerObserver>)observer
+{
+  // before we run uimanager batch complete, we override coordinator observers list
+  // to avoid observers from firing. This is done because we only want the uimanager
+  // related operations to run and not all other operations (including the ones enqueued
+  // by reanimated or native animated modules) from being scheduled. If we were to allow
+  // other modules to execute some logic from this sync uimanager run there is a possibility
+  // that the commands will execute out of order or that we intercept a batch of commands that
+  // those modules may be in a middle of (we verify that batch isn't in progress for uimodule
+  // but can't do the same for all remaining modules)
+
+  // store reference to the observers array
+  id oldObservers = [self.observerCoordinator valueForKey:@"_observers"];
+
+  // temporarily replace observers with a table conatining just nodesmanager (we need
+  // this to capture mounting block)
+  NSHashTable<id<RCTUIManagerObserver>> *soleObserver = [NSHashTable new];
+  [soleObserver addObject:observer];
+  [self.observerCoordinator setValue:soleObserver forKey:@"_observers"];
+
+  // run batch
+  [self batchDidComplete];
+  // restore old observers table
+  [self.observerCoordinator setValue:oldObservers forKey:@"_observers"];
+}
+
+@end
+
+@interface REANodesManager () <RCTUIManagerObserver>
+
+@end
+
+@implementation REANodesManager {
+  CADisplayLink *_displayLink;
+  BOOL _wantRunUpdates;
+  NSMutableArray<REAOnAnimationCallback> *_onAnimationCallbacks;
+  BOOL _tryRunBatchUpdatesSynchronously;
+  REAEventHandler _eventHandler;
+  volatile void (^_mounting)(void);
+  NSMutableDictionary<NSNumber *, ComponentUpdate *> *_componentUpdateBuffer;
+  NSMutableDictionary<NSNumber *, UIView *> *_viewRegistry;
+#ifdef RCT_NEW_ARCH_ENABLED
+  __weak RCTBridge *_bridge;
+  REAPerformOperations _performOperations;
+  __weak id<RCTSurfacePresenterStub> _surfacePresenter;
+  NSMutableDictionary<NSNumber *, NSMutableDictionary *> *_operationsInBatch;
+#else
+  NSMutableArray<REANativeAnimationOp> *_operationsInBatch;
+  volatile atomic_bool _shouldFlushUpdateBuffer;
+#endif
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (nonnull instancetype)initWithModule:(REAModule *)reanimatedModule
+                                bridge:(RCTBridge *)bridge
+                      surfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  if ((self = [super init])) {
+    _bridge = bridge;
+    _surfacePresenter = surfacePresenter;
+    _reanimatedModule = reanimatedModule;
+    _wantRunUpdates = NO;
+    _onAnimationCallbacks = [NSMutableArray new];
+    _operationsInBatch = [NSMutableDictionary new];
+    _componentUpdateBuffer = [NSMutableDictionary new];
+    _viewRegistry = [_uiManager valueForKey:@"_viewRegistry"];
+  }
+
+  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(onAnimationFrame:)];
+  _displayLink.preferredFramesPerSecond = 120; // will fallback to 60 fps for devices without Pro Motion display
+  [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+  [_displayLink setPaused:true];
+  return self;
+}
+#else
+- (instancetype)initWithModule:(REAModule *)reanimatedModule uiManager:(RCTUIManager *)uiManager
+{
+  if ((self = [super init])) {
+    _reanimatedModule = reanimatedModule;
+    _uiManager = uiManager;
+    _wantRunUpdates = NO;
+    _onAnimationCallbacks = [NSMutableArray new];
+    _operationsInBatch = [NSMutableArray new];
+    _componentUpdateBuffer = [NSMutableDictionary new];
+    _viewRegistry = [_uiManager valueForKey:@"_viewRegistry"];
+    _shouldFlushUpdateBuffer = false;
+  }
+
+  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(onAnimationFrame:)];
+  _displayLink.preferredFramesPerSecond = 120; // will fallback to 60 fps for devices without Pro Motion display
+  [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+  [_displayLink setPaused:true];
+  return self;
+}
+#endif
+
+- (void)invalidate
+{
+  _eventHandler = nil;
+  [_displayLink invalidate];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter
+{
+  _surfacePresenter = surfacePresenter;
+}
+#endif
+
+- (void)operationsBatchDidComplete
+{
+  if (![_displayLink isPaused]) {
+    // if display link is set it means some of the operations that have run as a part of the batch
+    // requested updates. We want updates to be run in the same frame as in which operations have
+    // been scheduled as it may mean the new view has just been mounted and expects its initial
+    // props to be calculated.
+    // Unfortunately if the operation has just scheduled animation callback it won't run until the
+    // next frame, so it's being triggered manually.
+    _wantRunUpdates = YES;
+    [self performOperations];
+  }
+}
+
+- (void)postOnAnimation:(REAOnAnimationCallback)clb
+{
+  [_onAnimationCallbacks addObject:clb];
+  [self startUpdatingOnAnimationFrame];
+}
+
+- (void)registerEventHandler:(REAEventHandler)eventHandler
+{
+  _eventHandler = eventHandler;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)registerPerformOperations:(REAPerformOperations)performOperations
+{
+  _performOperations = performOperations;
+}
+#endif
+
+- (void)startUpdatingOnAnimationFrame
+{
+  // Setting _currentAnimationTimestamp here is connected with manual triggering of performOperations
+  // in operationsBatchDidComplete. If new node has been created and clock has not been started,
+  // _displayLink won't be initialized soon enough and _displayLink.timestamp will be 0.
+  // However, CADisplayLink is using CACurrentMediaTime so if there's need to perform one more
+  // evaluation, it could be used it here. In usual case, CACurrentMediaTime is not being used in
+  // favor of setting it with _displayLink.timestamp in onAnimationFrame method.
+  _currentAnimationTimestamp = CACurrentMediaTime();
+  [_displayLink setPaused:false];
+}
+
+- (void)stopUpdatingOnAnimationFrame
+{
+  if (_displayLink) {
+    [_displayLink setPaused:true];
+  }
+}
+
+- (void)onAnimationFrame:(CADisplayLink *)displayLink
+{
+  _currentAnimationTimestamp = _displayLink.timestamp;
+
+  NSArray<REAOnAnimationCallback> *callbacks = _onAnimationCallbacks;
+  _onAnimationCallbacks = [NSMutableArray new];
+
+  // When one of the callbacks would postOnAnimation callback we don't want
+  // to process it until the next frame. This is why we cpy the array before
+  // we iterate over it
+  for (REAOnAnimationCallback block in callbacks) {
+    block(displayLink);
+  }
+
+  [self performOperations];
+
+  if (_onAnimationCallbacks.count == 0) {
+    [self stopUpdatingOnAnimationFrame];
+  }
+}
+
+- (BOOL)uiManager:(RCTUIManager *)manager performMountingWithBlock:(RCTUIManagerMountingBlock)block
+{
+  RCTAssert(_mounting == nil, @"Mouting block is expected to not be set");
+  _mounting = block;
+  return YES;
+}
+
+- (void)performOperations
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  _performOperations(); // calls NativeReanimatedModule::performOperations
+  _wantRunUpdates = NO;
+#else
+  if (_operationsInBatch.count != 0) {
+    NSMutableArray<REANativeAnimationOp> *copiedOperationsQueue = _operationsInBatch;
+    _operationsInBatch = [NSMutableArray new];
+
+    BOOL trySynchronously = _tryRunBatchUpdatesSynchronously;
+    _tryRunBatchUpdatesSynchronously = NO;
+
+    __weak __typeof__(self) weakSelf = self;
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    RCTExecuteOnUIManagerQueue(^{
+      __typeof__(self) strongSelf = weakSelf;
+      if (strongSelf == nil) {
+        return;
+      }
+      BOOL canUpdateSynchronously = trySynchronously && ![strongSelf.uiManager hasEnqueuedUICommands];
+
+      if (!canUpdateSynchronously) {
+        dispatch_semaphore_signal(semaphore);
+      }
+
+      for (int i = 0; i < copiedOperationsQueue.count; i++) {
+        copiedOperationsQueue[i](strongSelf.uiManager);
+      }
+
+      if (canUpdateSynchronously) {
+        [strongSelf.uiManager runSyncUIUpdatesWithObserver:self];
+        dispatch_semaphore_signal(semaphore);
+      }
+      // In case canUpdateSynchronously=true we still have to send uiManagerWillPerformMounting event
+      // to observers because some components (e.g. TextInput) update their UIViews only on that event.
+      [strongSelf.uiManager setNeedsLayout];
+    });
+    if (trySynchronously) {
+      dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+    }
+
+    if (_mounting) {
+      _mounting();
+      _mounting = nil;
+    }
+  }
+  _wantRunUpdates = NO;
+#endif
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else
+- (void)enqueueUpdateViewOnNativeThread:(nonnull NSNumber *)reactTag
+                               viewName:(NSString *)viewName
+                            nativeProps:(NSMutableDictionary *)nativeProps
+                       trySynchronously:(BOOL)trySync
+{
+  if (trySync) {
+    _tryRunBatchUpdatesSynchronously = YES;
+  }
+  [_operationsInBatch addObject:^(RCTUIManager *uiManager) {
+    [uiManager updateView:reactTag viewName:viewName props:nativeProps];
+  }];
+}
+#endif
+
+- (BOOL)isDirectEvent:(id<RCTEvent>)event
+{
+  static NSArray<NSString *> *directEventNames;
+  static dispatch_once_t directEventNamesToken;
+  dispatch_once(&directEventNamesToken, ^{
+    directEventNames = @[
+      @"topContentSizeChange",
+      @"topMomentumScrollBegin",
+      @"topMomentumScrollEnd",
+      @"topScroll",
+      @"topScrollBeginDrag",
+      @"topScrollEndDrag"
+    ];
+  });
+
+  return [directEventNames containsObject:RCTNormalizeInputEventName(event.eventName)];
+}
+
+- (void)dispatchEvent:(id<RCTEvent>)event
+{
+  NSString *key = [NSString stringWithFormat:@"%@%@", event.viewTag, RCTNormalizeInputEventName(event.eventName)];
+
+  NSString *eventHash = [NSString stringWithFormat:@"%@%@", event.viewTag, event.eventName];
+
+  if (_eventHandler != nil) {
+    __weak REAEventHandler eventHandler = _eventHandler;
+    __weak __typeof__(self) weakSelf = self;
+    RCTExecuteOnMainQueue(^void() {
+      __typeof__(self) strongSelf = weakSelf;
+      if (strongSelf == nil) {
+        return;
+      }
+      if (eventHandler == nil) {
+        return;
+      }
+      eventHandler(eventHash, event);
+      if ([strongSelf isDirectEvent:event]) {
+        [strongSelf performOperations];
+      }
+    });
+  }
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else
+- (void)configureUiProps:(nonnull NSSet<NSString *> *)uiPropsSet
+          andNativeProps:(nonnull NSSet<NSString *> *)nativePropsSet
+{
+  _uiProps = uiPropsSet;
+  _nativeProps = nativePropsSet;
+}
+#endif
+
+- (BOOL)isNativeViewMounted:(NSNumber *)viewTag
+{
+  return _viewRegistry[viewTag].superview != nil;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+- (void)synchronouslyUpdateViewOnUIThread:(nonnull NSNumber *)viewTag props:(nonnull NSDictionary *)uiProps
+{
+  // adapted from RCTPropsAnimatedNode.m
+  RCTSurfacePresenter *surfacePresenter = _bridge.surfacePresenter ?: _surfacePresenter;
+  [surfacePresenter synchronouslyUpdateViewOnUIThread:viewTag props:uiProps];
+
+  // `synchronouslyUpdateViewOnUIThread` does not flush props like `backgroundColor` etc.
+  // so that's why we need to call `finalizeUpdates` here.
+  RCTComponentViewRegistry *componentViewRegistry = surfacePresenter.mountingManager.componentViewRegistry;
+  UIView<RCTComponentViewProtocol> *componentView =
+      [componentViewRegistry findComponentViewWithTag:[viewTag integerValue]];
+  [componentView finalizeUpdates:RNComponentViewUpdateMask{}];
+}
+
+#else
+
+- (void)updateProps:(nonnull NSDictionary *)props
+      ofViewWithTag:(nonnull NSNumber *)viewTag
+           withName:(nonnull NSString *)viewName
+{
+  ComponentUpdate *lastSnapshot = _componentUpdateBuffer[viewTag];
+  BOOL isNativeViewMounted = [self isNativeViewMounted:viewTag];
+
+  if (lastSnapshot != nil) {
+    NSMutableDictionary *lastProps = lastSnapshot.props;
+    for (NSString *key in props) {
+      [lastProps setValue:props[key] forKey:key];
+    }
+  }
+
+  // If the component isn't mounted, we will bail early with a scheduled update
+  if (!isNativeViewMounted) {
+    if (lastSnapshot == nil) {
+      ComponentUpdate *propsSnapshot = [ComponentUpdate new];
+      propsSnapshot.props = [props mutableCopy];
+      propsSnapshot.viewTag = viewTag;
+      propsSnapshot.viewName = viewName;
+      _componentUpdateBuffer[viewTag] = propsSnapshot;
+      atomic_store(&_shouldFlushUpdateBuffer, true);
+    }
+
+    return;
+  }
+
+  // The component may have been mounted with a pending snapshot (due to a race condition),
+  // so we should attempt run the update. Otherwise, the next call to -maybeFlushUpdateBuffer
+  // will only arrive when a new component is mounted (which might be never!)
+  //
+  // If there are 0 remaining items in the buffer, we can skip the run in -maybeFlushUpdateBuffer.
+  if (lastSnapshot != nil && isNativeViewMounted) {
+    props = lastSnapshot.props;
+    viewTag = lastSnapshot.viewTag;
+    viewName = lastSnapshot.viewName;
+
+    [_componentUpdateBuffer removeObjectForKey:viewTag];
+
+    if (_componentUpdateBuffer.count == 0) {
+      atomic_store(&_shouldFlushUpdateBuffer, false);
+    }
+  }
+
+  // TODO: refactor PropsNode to also use this function
+  NSMutableDictionary *uiProps = [NSMutableDictionary new];
+  NSMutableDictionary *nativeProps = [NSMutableDictionary new];
+  NSMutableDictionary *jsProps = [NSMutableDictionary new];
+
+  void (^addBlock)(NSString *key, id obj, BOOL *stop) = ^(NSString *key, id obj, BOOL *stop) {
+    if ([self.uiProps containsObject:key]) {
+      uiProps[key] = obj;
+    } else if ([self.nativeProps containsObject:key]) {
+      nativeProps[key] = obj;
+    } else {
+      jsProps[key] = obj;
+    }
+  };
+
+  [props enumerateKeysAndObjectsUsingBlock:addBlock];
+
+  if (uiProps.count > 0) {
+    [self.uiManager synchronouslyUpdateViewOnUIThread:viewTag viewName:viewName props:uiProps];
+  }
+  if (nativeProps.count > 0) {
+    [self enqueueUpdateViewOnNativeThread:viewTag viewName:viewName nativeProps:nativeProps trySynchronously:YES];
+  }
+  if (jsProps.count > 0) {
+    [self.reanimatedModule sendEventWithName:@"onReanimatedPropsChange"
+                                        body:@{@"viewTag" : viewTag, @"props" : jsProps}];
+  }
+}
+
+- (NSString *)obtainProp:(nonnull NSNumber *)viewTag propName:(nonnull NSString *)propName
+{
+  UIView *view = [self.uiManager viewForReactTag:viewTag];
+
+  NSString *result =
+      [NSString stringWithFormat:@"error: unknown propName %@, currently supported: opacity, zIndex", propName];
+
+  if ([propName isEqualToString:@"opacity"]) {
+    CGFloat alpha = view.alpha;
+    result = [@(alpha) stringValue];
+  } else if ([propName isEqualToString:@"zIndex"]) {
+    NSInteger zIndex = view.reactZIndex;
+    result = [@(zIndex) stringValue];
+  }
+
+  return result;
+}
+
+- (void)maybeFlushUpdateBuffer
+{
+  RCTAssertUIManagerQueue();
+  bool shouldFlushUpdateBuffer = atomic_load(&_shouldFlushUpdateBuffer);
+  if (!shouldFlushUpdateBuffer) {
+    return;
+  }
+
+  __weak __typeof__(self) weakSelf = self;
+  [_uiManager addUIBlock:^(__unused RCTUIManager *manager, __unused NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    __typeof__(self) strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return;
+    }
+    atomic_store(&strongSelf->_shouldFlushUpdateBuffer, false);
+    NSMutableDictionary *componentUpdateBuffer = [strongSelf->_componentUpdateBuffer copy];
+    strongSelf->_componentUpdateBuffer = [NSMutableDictionary new];
+    for (NSNumber *tag in componentUpdateBuffer) {
+      ComponentUpdate *componentUpdate = componentUpdateBuffer[tag];
+      if (componentUpdate == Nil) {
+        continue;
+      }
+      [strongSelf updateProps:componentUpdate.props
+                ofViewWithTag:componentUpdate.viewTag
+                     withName:componentUpdate.viewName];
+    }
+    [strongSelf performOperations];
+  }];
+}
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/ios/keyboardObserver/REAKeyboardEventObserver.h

@@ -0,0 +1,17 @@
+#ifndef REAKeyboardEventManager_h
+#define REAKeyboardEventManager_h
+
+#import <RNReanimated/REAEventDispatcher.h>
+#import <React/RCTEventDispatcher.h>
+
+typedef void (^KeyboardEventListenerBlock)(int keyboardState, int height);
+
+@interface REAKeyboardEventObserver : NSObject
+
+- (instancetype)init;
+- (int)subscribeForKeyboardEvents:(KeyboardEventListenerBlock)listener;
+- (void)unsubscribeFromKeyboardEvents:(int)listenerId;
+
+@end
+
+#endif /* REAKeyboardEventManager_h */