react-native-reanimated 2.8.0 → 3.0.0-rc.0

package/android/src/{main → paper}/java/com/swmansion/reanimated/NativeProxy.java

@@ -8,6 +8,7 @@ import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.ReactApplication;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableNativeArray;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
@@ -15,6 +16,7 @@ import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.facebook.soloader.SoLoader;
 import com.swmansion.common.GestureHandlerStateManager;
 import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
 import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
@@ -31,7 +33,7 @@ import java.util.Set;
 public class NativeProxy {
 
   static {
-    System.loadLibrary("reanimated");
+    SoLoader.loadLibrary("reanimated");
   }
 
   @DoNotStrip
@@ -104,9 +106,13 @@ public class NativeProxy {
         (CallInvokerHolderImpl) context.getCatalystInstance().getJSCallInvokerHolder();
     LayoutAnimations LayoutAnimations = new LayoutAnimations(context);
     mScheduler = new Scheduler(context);
+
     mHybridData =
         initHybrid(
-            context.getJavaScriptContextHolder().get(), holder, mScheduler, LayoutAnimations);
+            context.getJavaScriptContextHolder().get(),
+            holder,
+            mScheduler,
+            LayoutAnimations);
     mContext = new WeakReference<>(context);
     prepare(LayoutAnimations);
     reanimatedSensorContainer = new ReanimatedSensorContainer(mContext);
@@ -135,6 +141,8 @@ public class NativeProxy {
 
   public native boolean isAnyHandlerWaitingForEvent(String eventName);
 
+  public native void performOperations();
+
   public Scheduler getScheduler() {
     return mScheduler;
   }
@@ -170,6 +178,11 @@ public class NativeProxy {
     mNodesManager.updateProps(viewTag, props);
   }
 
+  @DoNotStrip
+  private void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+    mNodesManager.synchronouslyUpdateUIProps(viewTag, uiProps);
+  }
+
   @DoNotStrip
   private String obtainProp(int viewTag, String propName) {
     return mNodesManager.obtainProp(viewTag, propName);

package/android/src/paper/java/com/swmansion/reanimated/ReaCompatibility.java

@@ -0,0 +1,17 @@
+package com.swmansion.reanimated;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+
+class ReaCompatibility {
+    public ReaCompatibility(ReactApplicationContext reactApplicationContext) {
+
+    }
+    public void registerFabricEventListener(NodesManager nodeManager) {
+
+    }
+    public void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+
+    }
+}

package/ios/Fabric/REAInitializerRCTFabricSurface.h

@@ -0,0 +1,12 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <RNReanimated/REAModule.h>
+#import <React/RCTFabricSurface.h>
+
+@interface REAInitializerRCTFabricSurface : RCTFabricSurface
+
+@property REAModule *reaModule;
+
+@end
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/Fabric/REAInitializerRCTFabricSurface.mm

@@ -0,0 +1,73 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTSurface.h>
+#import <React/RCTSurfaceView.h>
+#import <memory>
+
+#import <RNReanimated/REAInitializerRCTFabricSurface.h>
+#import <RNReanimated/REAModule.h>
+
+@implementation REAInitializerRCTFabricSurface {
+  std::shared_ptr<facebook::react::SurfaceHandler> _surfaceHandler;
+  int _tag;
+  RCTSurface *_surface;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _tag = -1;
+    _surface = [[RCTSurface alloc] init];
+    _surfaceHandler = std::make_shared<facebook::react::SurfaceHandler>("REASurface", _tag);
+  }
+  return self;
+}
+
+- (NSNumber *)rootViewTag
+{
+  return @(_tag);
+}
+
+- (NSInteger)rootTag
+{
+  return (NSInteger)_tag;
+}
+
+- (void)start
+{
+  // this is only needed method, the rest of them is just for prevent null pointer exceptions
+  [_reaModule installReanimatedUIManagerBindingAfterReload];
+}
+
+- (facebook::react::SurfaceHandler const &)surfaceHandler
+{
+  return *_surfaceHandler.get();
+}
+
+- (void)setMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+}
+
+- (void)setMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize viewportOffset:(CGPoint)viewportOffset
+{
+}
+
+- (void)stop
+{
+}
+
+- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
+{
+  CGSize size{0, 0};
+  return size;
+}
+
+- (nonnull RCTSurfaceView *)view
+{
+  // This method should never be called.
+  react_native_assert(false);
+}
+
+@end
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/REAEventDispatcher.m

@@ -1,5 +1,4 @@
 #import <RNReanimated/REAEventDispatcher.h>
-#import <RNReanimated/REAModule.h>
 #import <React/RCTBridge+Private.h>
 #import <React/RCTDefines.h>
 

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 @[];
+}
+
+- (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