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

package/ios/REAModule.h

@@ -1,3 +1,8 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNReanimated/NewestShadowNodesRegistry.h>
+#import <RNReanimated/ReanimatedUIManagerBinding.h>
+#endif
+
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventDispatcher.h>
 #import <React/RCTEventEmitter.h>
@@ -5,10 +10,14 @@
 #import <React/RCTUIManagerObserverCoordinator.h>
 #import <React/RCTUIManagerUtils.h>
 
-#import <RNReanimated/REAValueNode.h>
+#import <RNReanimated/REANodesManager.h>
 
 @interface REAModule : RCTEventEmitter <RCTBridgeModule, RCTEventDispatcherObserver, RCTUIManagerObserver>
 
 @property (nonatomic, readonly) REANodesManager *nodesManager;
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)installReanimatedUIManagerBindingAfterReload;
+#endif
+
 @end

package/ios/REAModule.mm

@@ -0,0 +1,284 @@
+#import <React/RCTBridge+Private.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTFabricSurface.h>
+#import <React/RCTScheduler.h>
+#import <React/RCTSurface.h>
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <React/RCTSurfaceView.h>
+#endif
+
+#import <RNReanimated/NativeProxy.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNReanimated/NewestShadowNodesRegistry.h>
+#import <RNReanimated/REAInitializerRCTFabricSurface.h>
+#import <RNReanimated/ReanimatedUIManagerBinding.h>
+#endif
+
+#import <RNReanimated/REAModule.h>
+#import <RNReanimated/REANodesManager.h>
+
+using namespace facebook::react;
+using namespace reanimated;
+
+@interface RCTBridge (JSIRuntime)
+- (void *)runtime;
+@end
+
+@interface RCTBridge (RCTTurboModule)
+- (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
+- (void)_tryAndHandleError:(dispatch_block_t)block;
+@end
+
+#ifdef RCT_NEW_ARCH_ENABLED
+static __strong REAInitializerRCTFabricSurface *reaSurface;
+#else
+typedef void (^AnimatedOperation)(REANodesManager *nodesManager);
+#endif
+
+@implementation REAModule {
+#ifdef RCT_NEW_ARCH_ENABLED
+  __weak RCTSurfacePresenter *_surfacePresenter;
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry;
+  std::weak_ptr<NativeReanimatedModule> reanimatedModule_;
+  std::shared_ptr<EventListener> eventListener_;
+#else
+  NSMutableArray<AnimatedOperation> *_operations;
+#endif
+}
+
+RCT_EXPORT_MODULE(ReanimatedModule);
+
+- (void)invalidate
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  RCTScheduler *scheduler = [_surfacePresenter scheduler];
+  [scheduler removeEventListener:eventListener_];
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+#endif
+  [_nodesManager invalidate];
+  [super invalidate];
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  // This module needs to be on the same queue as the UIManager to avoid
+  // having to lock `_operations` and `_preOperations` since `uiManagerWillPerformMounting`
+  // will be called from that queue.
+  return RCTGetUIManagerQueue();
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+- (std::shared_ptr<UIManager>)getUIManager
+{
+  RCTScheduler *scheduler = [_surfacePresenter scheduler];
+  return scheduler.uiManager;
+}
+
+- (void)injectReanimatedUIManagerBinding:(jsi::Runtime &)runtime uiManager:(std::shared_ptr<UIManager>)uiManager
+{
+  RuntimeExecutor syncRuntimeExecutor = [&](std::function<void(jsi::Runtime & runtime_)> &&callback) {
+    callback(runtime);
+  };
+  ReanimatedUIManagerBinding::createAndInstallIfNeeded(
+      runtime, syncRuntimeExecutor, uiManager, newestShadowNodesRegistry);
+}
+
+- (void)setUpNativeReanimatedModule:(std::shared_ptr<UIManager>)uiManager
+{
+  if (auto reanimatedModule = reanimatedModule_.lock()) {
+    reanimatedModule->setUIManager(uiManager);
+    reanimatedModule->setNewestShadowNodesRegistry(newestShadowNodesRegistry);
+  }
+}
+
+- (void)injectDependencies:(jsi::Runtime &)runtime
+{
+  auto uiManager = [self getUIManager];
+  react_native_assert(uiManager.get() != nil);
+  newestShadowNodesRegistry = std::make_shared<NewestShadowNodesRegistry>();
+  [self injectReanimatedUIManagerBinding:runtime uiManager:uiManager];
+  [self setUpNativeReanimatedModule:uiManager];
+}
+
+#pragma mark-- Initialize
+
+- (void)installReanimatedUIManagerBindingAfterReload
+{
+  // called from REAInitializerRCTFabricSurface::start
+  __weak __typeof__(self) weakSelf = self;
+  _surfacePresenter = self.bridge.surfacePresenter;
+  [_nodesManager setSurfacePresenter:_surfacePresenter];
+
+  // to avoid deadlock we can't use Executor from React Native
+  // but we can create own and use it because initialization is already synchronized
+  react_native_assert(self.bridge != nil);
+  RCTRuntimeExecutorFromBridge(self.bridge)(^(jsi::Runtime &runtime) {
+    if (__typeof__(self) strongSelf = weakSelf) {
+      [strongSelf injectDependencies:runtime];
+    }
+  });
+}
+
+- (void)handleJavaScriptDidLoadNotification:(NSNotification *)notification
+{
+  _surfacePresenter = self.bridge.surfacePresenter;
+  RCTScheduler *scheduler = [_surfacePresenter scheduler];
+  __weak __typeof__(self) weakSelf = self;
+  _surfacePresenter.runtimeExecutor(^(jsi::Runtime &runtime) {
+    __typeof__(self) strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return;
+    }
+    if (auto reanimatedModule = strongSelf->reanimatedModule_.lock()) {
+      self->eventListener_ =
+          std::make_shared<facebook::react::EventListener>([reanimatedModule](const RawEvent &rawEvent) {
+            if (!RCTIsMainQueue()) {
+              // event listener called on the JS thread, let's ignore this event
+              // as we cannot safely access worklet runtime here
+              // and also we don't care about topLayout events
+              return false;
+            }
+            return reanimatedModule->handleRawEvent(rawEvent, CACurrentMediaTime() * 1000);
+          });
+      [scheduler addEventListener:self->eventListener_];
+    }
+  });
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  [super setBridge:bridge];
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(handleJavaScriptDidLoadNotification:)
+                                               name:RCTJavaScriptDidLoadNotification
+                                             object:nil];
+
+  [[self.moduleRegistry moduleForName:"EventDispatcher"] addDispatchObserver:self];
+  [bridge.uiManager.observerCoordinator addObserver:self];
+
+  // only within the first loading `self.bridge.surfacePresenter` exists
+  // during the reload `self.bridge.surfacePresenter` is null
+  _surfacePresenter = self.bridge.surfacePresenter;
+#ifdef DEBUG
+  if (reaSurface == nil) {
+    // we need only one instance because SurfacePresenter is the same during the application lifetime
+    reaSurface = [[REAInitializerRCTFabricSurface alloc] init];
+    [_surfacePresenter registerSurface:reaSurface];
+  }
+  reaSurface.reaModule = self;
+#endif
+
+  if (_surfacePresenter == nil) {
+    // _surfacePresenter will be set in installReanimatedUIManagerBindingAfterReload
+    _nodesManager = [[REANodesManager alloc] initWithModule:self bridge:self.bridge surfacePresenter:nil];
+    return;
+  }
+
+  _nodesManager = [[REANodesManager alloc] initWithModule:self bridge:self.bridge surfacePresenter:_surfacePresenter];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(installTurboModule)
+{
+  facebook::jsi::Runtime *jsiRuntime = [self.bridge respondsToSelector:@selector(runtime)]
+      ? reinterpret_cast<facebook::jsi::Runtime *>(self.bridge.runtime)
+      : nullptr;
+
+  if (jsiRuntime) {
+    // Reanimated
+    jsi::Runtime &runtime = *jsiRuntime;
+
+    auto reanimatedModule = reanimated::createReanimatedModule(self.bridge, self.bridge.jsCallInvoker);
+
+    auto workletRuntimeValue = runtime.global()
+                                   .getProperty(runtime, "ArrayBuffer")
+                                   .asObject(runtime)
+                                   .asFunction(runtime)
+                                   .callAsConstructor(runtime, {static_cast<double>(sizeof(void *))});
+    uintptr_t *workletRuntimeData =
+        reinterpret_cast<uintptr_t *>(workletRuntimeValue.getObject(runtime).getArrayBuffer(runtime).data(runtime));
+    workletRuntimeData[0] = reinterpret_cast<uintptr_t>(reanimatedModule->runtime.get());
+
+    runtime.global().setProperty(runtime, "_WORKLET_RUNTIME", workletRuntimeValue);
+
+    runtime.global().setProperty(runtime, "_IS_FABRIC", true);
+
+    runtime.global().setProperty(
+        runtime,
+        jsi::PropNameID::forAscii(runtime, "__reanimatedModuleProxy"),
+        jsi::Object::createFromHostObject(runtime, reanimatedModule));
+    reanimatedModule_ = reanimatedModule;
+    if (_surfacePresenter != nil) {
+      // reload, uiManager is null right now, we need to wait for `installReanimatedUIManagerBindingAfterReload`
+      [self injectDependencies:runtime];
+    }
+  }
+  return nil;
+}
+
+#else
+
+RCT_EXPORT_METHOD(installTurboModule)
+{
+  // TODO: Move initialization from UIResponder+Reanimated to here
+}
+
+- (void)setBridge:(RCTBridge *)bridge
+{
+  [super setBridge:bridge];
+
+  _nodesManager = [[REANodesManager alloc] initWithModule:self uiManager:self.bridge.uiManager];
+  _operations = [NSMutableArray new];
+
+  [bridge.uiManager.observerCoordinator addObserver:self];
+}
+
+#pragma mark-- Batch handling
+
+- (void)addOperationBlock:(AnimatedOperation)operation
+{
+  [_operations addObject:operation];
+}
+
+#pragma mark - RCTUIManagerObserver
+
+- (void)uiManagerWillPerformMounting:(RCTUIManager *)uiManager
+{
+  [_nodesManager maybeFlushUpdateBuffer];
+  if (_operations.count == 0) {
+    return;
+  }
+
+  NSArray<AnimatedOperation> *operations = _operations;
+  _operations = [NSMutableArray new];
+
+  REANodesManager *nodesManager = _nodesManager;
+
+  [uiManager addUIBlock:^(__unused RCTUIManager *manager, __unused NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    for (AnimatedOperation operation in operations) {
+      operation(nodesManager);
+    }
+    [nodesManager operationsBatchDidComplete];
+  }];
+}
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+#pragma mark-- Events
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[ @"onReanimatedCall", @"onReanimatedPropsChange" ];
+}
+
+- (void)eventDispatcherWillDispatchEvent:(id<RCTEvent>)event
+{
+  // Events can be dispatched from any queue
+  [_nodesManager dispatchEvent:event];
+}
+
+@end

package/ios/REANodesManager.h

@@ -1,14 +1,20 @@
-#import <Foundation/Foundation.h>
-#import <RNReanimated/REANode.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTUIManager.h>
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTSurfacePresenterStub.h>
+#endif
+
 @class REAModule;
 
 typedef void (^REAOnAnimationCallback)(CADisplayLink *displayLink);
 typedef void (^REANativeAnimationOp)(RCTUIManager *uiManager);
 typedef void (^REAEventHandler)(NSString *eventName, id<RCTEvent> event);
 
+#ifdef RCT_NEW_ARCH_ENABLED
+typedef void (^REAPerformOperations)();
+#endif
+
 @interface REANodesManager : NSObject
 
 @property (nonatomic, weak, nullable) RCTUIManager *uiManager;
@@ -18,66 +24,36 @@ typedef void (^REAEventHandler)(NSString *eventName, id<RCTEvent> event);
 @property (nonatomic, nullable) NSSet<NSString *> *uiProps;
 @property (nonatomic, nullable) NSSet<NSString *> *nativeProps;
 
-- (nonnull instancetype)initWithModule:(REAModule *)reanimatedModule uiManager:(nonnull RCTUIManager *)uiManager;
-
-- (REANode *_Nullable)findNodeByID:(nonnull REANodeID)nodeID;
-
+#ifdef RCT_NEW_ARCH_ENABLED
+- (nonnull instancetype)initWithModule:(REAModule *)reanimatedModule
+                                bridge:(RCTBridge *)bridge
+                      surfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter;
+#else
+- (instancetype)initWithModule:(REAModule *)reanimatedModule uiManager:(RCTUIManager *)uiManager;
+#endif
 - (void)invalidate;
-
 - (void)operationsBatchDidComplete;
 
-//
-
 - (void)postOnAnimation:(REAOnAnimationCallback)clb;
-- (void)postRunUpdatesAfterAnimation;
 - (void)registerEventHandler:(REAEventHandler)eventHandler;
-- (void)enqueueUpdateViewOnNativeThread:(nonnull NSNumber *)reactTag
-                               viewName:(NSString *)viewName
-                            nativeProps:(NSMutableDictionary *)nativeProps
-                       trySynchronously:(BOOL)trySync;
-- (void)getValue:(REANodeID)nodeID callback:(RCTResponseSenderBlock)callback;
-
-// graph
-
-- (void)createNode:(nonnull REANodeID)tag config:(NSDictionary<NSString *, id> *__nonnull)config;
-
-- (void)dropNode:(nonnull REANodeID)tag;
-
-- (void)connectNodes:(nonnull REANodeID)parentID childID:(nonnull REANodeID)childID;
-
-- (void)disconnectNodes:(nonnull REANodeID)parentID childID:(nonnull REANodeID)childID;
-
-- (void)connectNodeToView:(nonnull REANodeID)nodeID
-                  viewTag:(nonnull NSNumber *)viewTag
-                 viewName:(nonnull NSString *)viewName;
-
-- (void)disconnectNodeFromView:(nonnull REANodeID)nodeID viewTag:(nonnull NSNumber *)viewTag;
-
-- (void)attachEvent:(nonnull NSNumber *)viewTag
-          eventName:(nonnull NSString *)eventName
-        eventNodeID:(nonnull REANodeID)eventNodeID;
-
-- (void)detachEvent:(nonnull NSNumber *)viewTag
-          eventName:(nonnull NSString *)eventName
-        eventNodeID:(nonnull REANodeID)eventNodeID;
-
-// configuration
+- (void)dispatchEvent:(id<RCTEvent>)event;
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)setSurfacePresenter:(id<RCTSurfacePresenterStub>)surfacePresenter;
+- (void)registerPerformOperations:(REAPerformOperations)performOperations;
+- (void)synchronouslyUpdateViewOnUIThread:(nonnull NSNumber *)viewTag props:(nonnull NSDictionary *)uiProps;
+#else
 - (void)configureUiProps:(nonnull NSSet<NSString *> *)uiPropsSet
           andNativeProps:(nonnull NSSet<NSString *> *)nativePropsSet;
-
 - (void)updateProps:(nonnull NSDictionary *)props
       ofViewWithTag:(nonnull NSNumber *)viewTag
            withName:(nonnull NSString *)viewName;
-
-- (NSString *)obtainProp:(nonnull NSNumber *)viewTag propName:(nonnull NSString *)propName;
-
-// events
-
-- (void)dispatchEvent:(id<RCTEvent>)event;
-
-- (void)setValueForNodeID:(nonnull NSNumber *)nodeID value:(nonnull NSNumber *)newValue;
-
 - (void)maybeFlushUpdateBuffer;
+- (void)enqueueUpdateViewOnNativeThread:(nonnull NSNumber *)reactTag
+                               viewName:(NSString *)viewName
+                            nativeProps:(NSMutableDictionary *)nativeProps
+                       trySynchronously:(BOOL)trySync;
+- (NSString *)obtainProp:(nonnull NSNumber *)viewTag propName:(nonnull NSString *)propName;
+#endif
 
 @end