react-native-reanimated 3.8.0 → 3.9.0-layout-animation-experimental

package/apple/native/NativeProxy.mm

@@ -1,6 +1,8 @@
 #import <RNReanimated/LayoutAnimationsManager.h>
 #import <RNReanimated/NativeMethods.h>
 #import <RNReanimated/NativeProxy.h>
+#import <RNReanimated/PlatformDepMethodsHolder.h>
+#import <RNReanimated/PlatformDepMethodsHolderImpl.h>
 #import <RNReanimated/REAAnimationsManager.h>
 #import <RNReanimated/REAIOSUIScheduler.h>
 #import <RNReanimated/REAJSIUtils.h>
@@ -38,28 +40,11 @@
 - (void *)runtime;
 @end
 
-@interface RCTUIManager (DispatchCommand)
-- (void)dispatchViewManagerCommand:(nonnull NSNumber *)reactTag
-                         commandID:(id /*(NSString or NSNumber) */)commandID
-                       commandArgs:(NSArray<id> *)commandArgs;
-@end
-
 namespace reanimated {
 
 using namespace facebook;
 using namespace react;
 
-static NSSet *convertProps(jsi::Runtime &rt, const jsi::Value &props)
-{
-  NSMutableSet *propsSet = [[NSMutableSet alloc] init];
-  jsi::Array propsNames = props.asObject(rt).asArray(rt);
-  for (int i = 0; i < propsNames.size(rt); i++) {
-    NSString *propName = @(propsNames.getValueAtIndex(rt, i).asString(rt).utf8(rt).c_str());
-    [propsSet addObject:propName];
-  }
-  return propsSet;
-}
-
 std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     RCTBridge *bridge,
     const std::shared_ptr<CallInvoker> &jsInvoker,
@@ -67,196 +52,69 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
 {
   REAModule *reaModule = [bridge moduleForClass:[REAModule class]];
 
-#ifdef RCT_NEW_ARCH_ENABLED
-  // nothing
-#else
-  RCTUIManager *uiManager = reaModule.nodesManager.uiManager;
-  auto updatePropsFunction = [reaModule](jsi::Runtime &rt, const jsi::Value &operations) -> void {
-    auto array = operations.asObject(rt).asArray(rt);
-    size_t length = array.size(rt);
-    for (size_t i = 0; i < length; ++i) {
-      auto item = array.getValueAtIndex(rt, i).asObject(rt);
-      int viewTag = item.getProperty(rt, "tag").asNumber();
-      const jsi::Value &viewName = item.getProperty(rt, "name");
-      const jsi::Object &props = item.getProperty(rt, "updates").asObject(rt);
-
-      NSString *nsViewName = [NSString stringWithCString:viewName.asString(rt).utf8(rt).c_str()
-                                                encoding:[NSString defaultCStringEncoding]];
-
-      NSDictionary *propsDict = convertJSIObjectToNSDictionary(rt, props);
-      [reaModule.nodesManager updateProps:propsDict ofViewWithTag:[NSNumber numberWithInt:viewTag] withName:nsViewName];
-    }
-  };
-
-  auto measureFunction = [uiManager](int viewTag) -> std::vector<std::pair<std::string, double>> {
-    return measure(viewTag, uiManager);
-  };
-
-  auto scrollToFunction = [uiManager](int viewTag, double x, double y, bool animated) {
-    scrollTo(viewTag, uiManager, x, y, animated);
-  };
-
-  auto dispatchCommandFunction =
-      [uiManager](
-          jsi::Runtime &rt, const int tag, const jsi::Value &commandNameValue, const jsi::Value &argsValue) -> void {
-    NSNumber *viewTag = [NSNumber numberWithInt:tag];
-    NSString *commandID = [NSString stringWithCString:commandNameValue.asString(rt).utf8(rt).c_str()
-                                             encoding:[NSString defaultCStringEncoding]];
-    NSArray *commandArgs = convertJSIArrayToNSArray(rt, argsValue.asObject(rt).asArray(rt));
-    RCTExecuteOnUIManagerQueue(^{
-      [uiManager dispatchViewManagerCommand:viewTag commandID:commandID commandArgs:commandArgs];
-    });
-  };
-
-#endif
-
-  id<RNGestureHandlerStateManager> gestureHandlerStateManager = nil;
-  auto setGestureStateFunction = [gestureHandlerStateManager, bridge](int handlerTag, int newState) mutable {
-    if (gestureHandlerStateManager == nil) {
-      gestureHandlerStateManager = [bridge moduleForName:@"RNGestureHandlerModule"];
-    }
-
-    setGestureState(gestureHandlerStateManager, handlerTag, newState);
-  };
+  auto nodesManager = reaModule.nodesManager;
 
-#ifdef RCT_NEW_ARCH_ENABLED
-  // nothing
-#else
-  auto obtainPropFunction = [reaModule](
-                                jsi::Runtime &rt, const int viewTag, const jsi::String &propName) -> jsi::Value {
-    NSString *propNameConverted = [NSString stringWithFormat:@"%s", propName.utf8(rt).c_str()];
-    std::string resultStr = std::string([[reaModule.nodesManager obtainProp:[NSNumber numberWithInt:viewTag]
-                                                                   propName:propNameConverted] UTF8String]);
-    jsi::Value val = jsi::String::createFromUtf8(rt, resultStr);
-    return val;
-  };
-#endif
+  jsi::Runtime &rnRuntime = *reinterpret_cast<facebook::jsi::Runtime *>(reaModule.bridge.runtime);
 
   auto jsQueue = std::make_shared<REAMessageThread>([NSRunLoop currentRunLoop], ^(NSError *error) {
     throw error;
   });
 
-  jsi::Runtime &rnRuntime = *reinterpret_cast<facebook::jsi::Runtime *>(reaModule.bridge.runtime);
+  PlatformDepMethodsHolder platformDepMethodsHolder = makePlatformDepMethodsHolder(bridge, nodesManager, reaModule);
 
   std::shared_ptr<UIScheduler> uiScheduler = std::make_shared<REAIOSUIScheduler>();
+  std::shared_ptr<JSScheduler> jsScheduler = std::make_shared<JSScheduler>(rnRuntime, jsInvoker);
+  constexpr bool isBridgeless = false;
 
-  auto nodesManager = reaModule.nodesManager;
-
-  auto maybeFlushUIUpdatesQueueFunction = [nodesManager]() { [nodesManager maybeFlushUIUpdatesQueue]; };
+  auto nativeReanimatedModule = std::make_shared<NativeReanimatedModule>(
+      rnRuntime, jsScheduler, jsQueue, uiScheduler, platformDepMethodsHolder, valueUnpackerCode, isBridgeless);
 
-  auto requestRender = [nodesManager](std::function<void(double)> onRender, jsi::Runtime &rt) {
-    [nodesManager postOnAnimation:^(READisplayLink *displayLink) {
-#if !TARGET_OS_OSX
-      auto targetTimestamp = displayLink.targetTimestamp;
+  commonInit(reaModule, nativeReanimatedModule);
+  // Layout Animation callbacks setup
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
 #else
-      // TODO macOS targetTimestamp isn't available on macOS
-      auto targetTimestamp = displayLink.timestamp + displayLink.duration;
-#endif
-      double frameTimestamp = calculateTimestampWithSlowAnimations(targetTimestamp) * 1000;
-      onRender(frameTimestamp);
-    }];
-  };
+  REAAnimationsManager *animationsManager = reaModule.animationsManager;
+  setupLayoutAnimationCallbacks(nativeReanimatedModule, animationsManager);
 
-#ifdef RCT_NEW_ARCH_ENABLED
-  auto synchronouslyUpdateUIPropsFunction = [nodesManager](jsi::Runtime &rt, Tag tag, const jsi::Object &props) {
-    NSNumber *viewTag = @(tag);
-    NSDictionary *uiProps = convertJSIObjectToNSDictionary(rt, props);
-    [nodesManager synchronouslyUpdateViewOnUIThread:viewTag props:uiProps];
-  };
+#endif // RCT_NEW_ARCH_ENABLED
 
-  auto progressLayoutAnimation = [=](jsi::Runtime &rt, int tag, const jsi::Object &newStyle, bool isSharedTransition) {
-    // noop
-  };
+  return nativeReanimatedModule;
+}
 
-  auto endLayoutAnimation = [=](int tag, bool removeView) {
-    // noop
-  };
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+std::shared_ptr<NativeReanimatedModule> createReanimatedModuleBridgeless(
+    RCTModuleRegistry *moduleRegistry,
+    jsi::Runtime &runtime,
+    const std::string &valueUnpackerCode,
+    RuntimeExecutor runtimeExecutor)
+{
+  REAModule *reaModule = [moduleRegistry moduleForName:"ReanimatedModule"];
 
-#else
-  // Layout Animations start
-  REAAnimationsManager *animationsManager = reaModule.animationsManager;
-  __weak REAAnimationsManager *weakAnimationsManager = animationsManager;
-
-  auto progressLayoutAnimation = [=](jsi::Runtime &rt, int tag, const jsi::Object &newStyle, bool isSharedTransition) {
-    NSDictionary *propsDict = convertJSIObjectToNSDictionary(rt, newStyle);
-    [weakAnimationsManager progressLayoutAnimationWithStyle:propsDict
-                                                     forTag:@(tag)
-                                         isSharedTransition:isSharedTransition];
-  };
-
-  auto endLayoutAnimation = [=](int tag, bool removeView) {
-    [weakAnimationsManager endLayoutAnimationForTag:@(tag) removeView:removeView];
-  };
-
-  auto configurePropsFunction = [reaModule](
-                                    jsi::Runtime &rt, const jsi::Value &uiProps, const jsi::Value &nativeProps) {
-    NSSet *uiPropsSet = convertProps(rt, uiProps);
-    NSSet *nativePropsSet = convertProps(rt, nativeProps);
-    [reaModule.nodesManager configureUiProps:uiPropsSet andNativeProps:nativePropsSet];
-  };
-
-  // Layout Animations end
-#endif
+  auto nodesManager = reaModule.nodesManager;
 
-  auto getAnimationTimestamp = []() { return calculateTimestampWithSlowAnimations(CACurrentMediaTime()) * 1000; };
-
-  // sensors
-  ReanimatedSensorContainer *reanimatedSensorContainer = [[ReanimatedSensorContainer alloc] init];
-  auto registerSensorFunction =
-      [=](int sensorType, int interval, int iosReferenceFrame, std::function<void(double[], int)> setter) -> int {
-    return [reanimatedSensorContainer registerSensor:(ReanimatedSensorType)sensorType
-                                            interval:interval
-                                   iosReferenceFrame:iosReferenceFrame
-                                              setter:^(double *data, int orientationDegrees) {
-                                                setter(data, orientationDegrees);
-                                              }];
-  };
-
-  auto unregisterSensorFunction = [=](int sensorId) { [reanimatedSensorContainer unregisterSensor:sensorId]; };
-  // end sensors
-
-  // keyboard events
-
-  REAKeyboardEventObserver *keyboardObserver = [[REAKeyboardEventObserver alloc] init];
-  auto subscribeForKeyboardEventsFunction =
-      [=](std::function<void(int keyboardState, int height)> keyboardEventDataUpdater, bool isStatusBarTranslucent) {
-        // ignore isStatusBarTranslucent - it's Android only
-        return [keyboardObserver subscribeForKeyboardEvents:^(int keyboardState, int height) {
-          keyboardEventDataUpdater(keyboardState, height);
-        }];
-      };
-
-  auto unsubscribeFromKeyboardEventsFunction = [=](int listenerId) {
-    [keyboardObserver unsubscribeFromKeyboardEvents:listenerId];
-  };
-  // end keyboard events
-
-  PlatformDepMethodsHolder platformDepMethodsHolder = {
-      requestRender,
-#ifdef RCT_NEW_ARCH_ENABLED
-      synchronouslyUpdateUIPropsFunction,
-#else
-      updatePropsFunction,
-      scrollToFunction,
-      dispatchCommandFunction,
-      measureFunction,
-      configurePropsFunction,
-      obtainPropFunction,
-#endif
-      getAnimationTimestamp,
-      progressLayoutAnimation,
-      endLayoutAnimation,
-      registerSensorFunction,
-      unregisterSensorFunction,
-      setGestureStateFunction,
-      subscribeForKeyboardEventsFunction,
-      unsubscribeFromKeyboardEventsFunction,
-      maybeFlushUIUpdatesQueueFunction,
-  };
+  auto jsQueue = std::make_shared<REAMessageThread>([NSRunLoop currentRunLoop], ^(NSError *error) {
+    throw error;
+  });
+
+  PlatformDepMethodsHolder platformDepMethodsHolder =
+      makePlatformDepMethodsHolderBridgeless(moduleRegistry, nodesManager, reaModule);
+
+  auto uiScheduler = std::make_shared<REAIOSUIScheduler>();
+  auto jsScheduler = std::make_shared<JSScheduler>(runtime, runtimeExecutor);
+  constexpr bool isBridgeless = true;
 
   auto nativeReanimatedModule = std::make_shared<NativeReanimatedModule>(
-      rnRuntime, jsInvoker, jsQueue, uiScheduler, platformDepMethodsHolder, valueUnpackerCode);
+      runtime, jsScheduler, jsQueue, uiScheduler, platformDepMethodsHolder, valueUnpackerCode, isBridgeless);
+
+  commonInit(reaModule, nativeReanimatedModule);
+
+  return nativeReanimatedModule;
+}
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
 
+void commonInit(REAModule *reaModule, std::shared_ptr<NativeReanimatedModule> nativeReanimatedModule)
+{
   [reaModule.nodesManager registerEventHandler:^(id<RCTEvent> event) {
     // handles RCTEvents from RNGestureHandler
     std::string eventName = [event.eventName UTF8String];
@@ -268,15 +126,24 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     nativeReanimatedModule->handleEvent(eventName, emitterReactTag, payload, currentTime);
   }];
 
-  std::weak_ptr<NativeReanimatedModule> weakNativeReanimatedModule = nativeReanimatedModule; // to avoid retain cycle
 #ifdef RCT_NEW_ARCH_ENABLED
+  std::weak_ptr<NativeReanimatedModule> weakNativeReanimatedModule = nativeReanimatedModule; // to avoid retain cycle
   [reaModule.nodesManager registerPerformOperations:^() {
     if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
       nativeReanimatedModule->performOperations();
     }
   }];
-#else
-  // Layout Animation callbacks setup
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else // RCT_NEW_ARCH_ENABLED
+void setupLayoutAnimationCallbacks(
+    std::shared_ptr<NativeReanimatedModule> nativeReanimatedModule,
+    REAAnimationsManager *animationsManager)
+{
+  std::weak_ptr<NativeReanimatedModule> weakNativeReanimatedModule = nativeReanimatedModule; // to avoid retain cycle
   [animationsManager
       setAnimationStartingBlock:^(NSNumber *_Nonnull tag, LayoutAnimationType type, NSDictionary *_Nonnull values) {
         if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
@@ -323,6 +190,12 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     }
   }];
 
+  [animationsManager setSharedTransitionRemovingBlock:^(NSNumber *_Nonnull tag) {
+    if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
+      nativeReanimatedModule->layoutAnimationsManager().clearSharedTransitionConfig([tag intValue]);
+    }
+  }];
+
   [animationsManager setCancelAnimationBlock:^(NSNumber *_Nonnull tag) {
     if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
       jsi::Runtime &rt = nativeReanimatedModule->getUIRuntime();
@@ -348,10 +221,7 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     }
   }];
 #endif // NDEBUG
-
-#endif
-
-  return nativeReanimatedModule;
 }
+#endif // RCT_NEW_ARCH_ENABLED
 
 } // namespace reanimated

package/apple/native/PlatformDepMethodsHolderImpl.h

@@ -0,0 +1,59 @@
+#if __cplusplus
+
+#import <REAAnimationsManager.h>
+#import <REAKeyboardEventObserver.h>
+#import <REAModule.h>
+#import <REANodesManager.h>
+#import <RNReanimated/NativeReanimatedModule.h>
+#import <React/RCTEventDispatcher.h>
+#import <ReanimatedSensorContainer.h>
+#include <memory>
+
+namespace reanimated {
+
+PlatformDepMethodsHolder makePlatformDepMethodsHolder(
+    RCTBridge *bridge,
+    REANodesManager *nodesManager,
+    REAModule *reaModule);
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+PlatformDepMethodsHolder makePlatformDepMethodsHolderBridgeless(
+    RCTModuleRegistry *moduleRegistry,
+    REANodesManager *nodesManager,
+    REAModule *reaModule);
+SetGestureStateFunction makeSetGestureStateFunctionBridgeless(
+    RCTModuleRegistry *moduleRegistry);
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+
+#ifdef RCT_NEW_ARCH_ENABLED
+SynchronouslyUpdateUIPropsFunction makeSynchronouslyUpdateUIPropsFunction(
+    REANodesManager *nodesManager);
+#else // RCT_NEW_ARCH_ENABLED
+UpdatePropsFunction makeUpdatePropsFunction(REAModule *reaModule);
+MeasureFunction makeMeasureFunction(RCTUIManager *uiManager);
+ScrollToFunction makeScrollToFunction(RCTUIManager *uiManager);
+DispatchCommandFunction makeDispatchCommandFunction(RCTUIManager *uiManager);
+ConfigurePropsFunction makeConfigurePropsFunction(REAModule *reaModule);
+ObtainPropFunction makeObtainPropFunction(REAModule *reaModule);
+#endif // RCT_NEW_ARCH_ENABLED
+
+SetGestureStateFunction makeSetGestureStateFunction(RCTBridge *bridge);
+RequestRenderFunction makeRequestRender(REANodesManager *nodesManager);
+GetAnimationTimestampFunction makeGetAnimationTimestamp();
+ProgressLayoutAnimationFunction makeProgressLayoutAnimation(
+    REAModule *reaModule);
+EndLayoutAnimationFunction makeEndLayoutAnimation(REAModule *reaModule);
+MaybeFlushUIUpdatesQueueFunction makeMaybeFlushUIUpdatesQueueFunction(
+    REANodesManager *nodesManager);
+RegisterSensorFunction makeRegisterSensorFunction(
+    ReanimatedSensorContainer *reanimatedSensorContainer);
+UnregisterSensorFunction makeUnregisterSensorFunction(
+    ReanimatedSensorContainer *reanimatedSensorContainer);
+KeyboardEventSubscribeFunction makeSubscribeForKeyboardEventsFunction(
+    REAKeyboardEventObserver *keyboardObserver);
+KeyboardEventUnsubscribeFunction makeUnsubscribeFromKeyboardEventsFunction(
+    REAKeyboardEventObserver *keyboardObserver);
+
+} // namespace reanimated
+
+#endif //__cplusplus