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

package/android/src/fabric/java/com/swmansion/reanimated/NativeProxy.java

@@ -0,0 +1,310 @@
+package com.swmansion.reanimated;
+
+import android.os.SystemClock;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.jni.HybridData;
+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;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.common.UIManagerType;
+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;
+import com.swmansion.reanimated.layoutReanimation.NativeMethodsHolder;
+import com.swmansion.reanimated.sensor.ReanimatedSensorContainer;
+import com.swmansion.reanimated.sensor.ReanimatedSensorType;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class NativeProxy {
+
+  static {
+    SoLoader.loadLibrary("reanimated");
+  }
+
+  @DoNotStrip
+  public static class AnimationFrameCallback implements NodesManager.OnAnimationFrame {
+
+    @DoNotStrip private final HybridData mHybridData;
+
+    @DoNotStrip
+    private AnimationFrameCallback(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    @Override
+    public native void onAnimationFrame(double timestampMs);
+  }
+
+  @DoNotStrip
+  public static class EventHandler implements RCTEventEmitter {
+
+    @DoNotStrip private final HybridData mHybridData;
+    private UIManagerModule.CustomEventNamesResolver mCustomEventNamesResolver;
+
+    @DoNotStrip
+    private EventHandler(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    @Override
+    public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+      String resolvedEventName = mCustomEventNamesResolver.resolveCustomEventName(eventName);
+      receiveEvent(targetTag + resolvedEventName, event);
+    }
+
+    public native void receiveEvent(String eventKey, @Nullable WritableMap event);
+
+    @Override
+    public void receiveTouches(
+        String eventName, WritableArray touches, WritableArray changedIndices) {
+      // not interested in processing touch events this way, we process raw events only
+    }
+  }
+
+  @DoNotStrip
+  public static class SensorSetter {
+
+    @DoNotStrip private final HybridData mHybridData;
+
+    @DoNotStrip
+    private SensorSetter(HybridData hybridData) {
+      mHybridData = hybridData;
+    }
+
+    public native void sensorSetter(float[] value);
+  }
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private final HybridData mHybridData;
+
+  private NodesManager mNodesManager;
+  private final WeakReference<ReactApplicationContext> mContext;
+  private Scheduler mScheduler = null;
+  private ReanimatedSensorContainer reanimatedSensorContainer;
+  private final GestureHandlerStateManager gestureHandlerStateManager;
+  private Long firstUptime = SystemClock.uptimeMillis();
+  private boolean slowAnimationsEnabled = false;
+
+  public NativeProxy(ReactApplicationContext context) {
+    CallInvokerHolderImpl holder =
+        (CallInvokerHolderImpl) context.getCatalystInstance().getJSCallInvokerHolder();
+    LayoutAnimations LayoutAnimations = new LayoutAnimations(context);
+    mScheduler = new Scheduler(context);
+    FabricUIManager fabricUIManager =
+        (FabricUIManager) UIManagerHelper.getUIManager(context, UIManagerType.FABRIC);
+
+    mHybridData =
+        initHybrid(
+            context.getJavaScriptContextHolder().get(),
+            holder,
+            mScheduler,
+            LayoutAnimations,
+            fabricUIManager);
+    mContext = new WeakReference<>(context);
+    prepare(LayoutAnimations);
+    reanimatedSensorContainer = new ReanimatedSensorContainer(mContext);
+    addDevMenuOption();
+
+    GestureHandlerStateManager tempHandlerStateManager;
+    try {
+      Class<NativeModule> gestureHandlerModuleClass =
+          (Class<NativeModule>)
+              Class.forName("com.swmansion.gesturehandler.react.RNGestureHandlerModule");
+      tempHandlerStateManager =
+          (GestureHandlerStateManager) context.getNativeModule(gestureHandlerModuleClass);
+    } catch (ClassCastException | ClassNotFoundException e) {
+      tempHandlerStateManager = null;
+    }
+    gestureHandlerStateManager = tempHandlerStateManager;
+  }
+
+  private native HybridData initHybrid(
+      long jsContext,
+      CallInvokerHolderImpl jsCallInvokerHolder,
+      Scheduler scheduler,
+      LayoutAnimations LayoutAnimations,
+      FabricUIManager fabricUIManager);
+
+  private native void installJSIBindings(FabricUIManager fabricUIManager);
+
+  public native boolean isAnyHandlerWaitingForEvent(String eventName);
+
+  public native void performOperations();
+
+  public Scheduler getScheduler() {
+    return mScheduler;
+  }
+
+  private void toggleSlowAnimations() {
+    slowAnimationsEnabled = !slowAnimationsEnabled;
+    if (slowAnimationsEnabled) {
+      firstUptime = SystemClock.uptimeMillis();
+    }
+  }
+
+  private void addDevMenuOption() {
+    // In Expo, `ApplicationContext` is not an instance of `ReactApplication`
+    if (mContext.get().getApplicationContext() instanceof ReactApplication) {
+      final DevSupportManager devSupportManager =
+          ((ReactApplication) mContext.get().getApplicationContext())
+              .getReactNativeHost()
+              .getReactInstanceManager()
+              .getDevSupportManager();
+
+      devSupportManager.addCustomDevOption(
+          "Toggle slow animations (Reanimated)", this::toggleSlowAnimations);
+    }
+  }
+
+  @DoNotStrip
+  private void requestRender(AnimationFrameCallback callback) {
+    mNodesManager.postOnAnimation(callback);
+  }
+
+  @DoNotStrip
+  private void updateProps(int viewTag, Map<String, Object> props) {
+    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);
+  }
+
+  @DoNotStrip
+  private void scrollTo(int viewTag, double x, double y, boolean animated) {
+    mNodesManager.scrollTo(viewTag, x, y, animated);
+  }
+
+  @DoNotStrip
+  private void setGestureState(int handlerTag, int newState) {
+    if (gestureHandlerStateManager != null) {
+      gestureHandlerStateManager.setGestureHandlerState(handlerTag, newState);
+    }
+  }
+
+  @DoNotStrip
+  private String getUptime() {
+    if (slowAnimationsEnabled) {
+      final long ANIMATIONS_DRAG_FACTOR = 10;
+      return Long.toString(
+          this.firstUptime
+              + (SystemClock.uptimeMillis() - this.firstUptime) / ANIMATIONS_DRAG_FACTOR);
+    } else {
+      return Long.toString(SystemClock.uptimeMillis());
+    }
+  }
+
+  @DoNotStrip
+  private float[] measure(int viewTag) {
+    return mNodesManager.measure(viewTag);
+  }
+
+  @DoNotStrip
+  private void configureProps(ReadableNativeArray uiProps, ReadableNativeArray nativeProps) {
+    Set<String> uiPropsSet = convertProps(uiProps);
+    Set<String> nativePropsSet = convertProps(nativeProps);
+    mNodesManager.configureProps(uiPropsSet, nativePropsSet);
+  }
+
+  private Set<String> convertProps(ReadableNativeArray props) {
+    Set<String> propsSet = new HashSet<>();
+    ArrayList<Object> propsList = props.toArrayList();
+    for (int i = 0; i < propsList.size(); i++) {
+      propsSet.add((String) propsList.get(i));
+    }
+    return propsSet;
+  }
+
+  @DoNotStrip
+  private void registerEventHandler(EventHandler handler) {
+    handler.mCustomEventNamesResolver = mNodesManager.getEventNameResolver();
+    mNodesManager.registerEventHandler(handler);
+  }
+
+  @DoNotStrip
+  private int registerSensor(int sensorType, int interval, SensorSetter setter) {
+    return reanimatedSensorContainer.registerSensor(
+        ReanimatedSensorType.getInstanceById(sensorType), interval, setter);
+  }
+
+  @DoNotStrip
+  private void unregisterSensor(int sensorId) {
+    reanimatedSensorContainer.unregisterSensor(sensorId);
+  }
+
+  public void onCatalystInstanceDestroy() {
+    mScheduler.deactivate();
+    mHybridData.resetNative();
+  }
+
+  public void prepare(LayoutAnimations LayoutAnimations) {
+    if (Utils.isChromeDebugger) {
+      Log.w("[REANIMATED]", "You can not use LayoutAnimation with enabled Chrome Debugger");
+      return;
+    }
+    mNodesManager = mContext.get().getNativeModule(ReanimatedModule.class).getNodesManager();
+    FabricUIManager fabricUIManager =
+        (FabricUIManager) UIManagerHelper.getUIManager(mContext.get(), UIManagerType.FABRIC);
+    installJSIBindings(fabricUIManager);
+    AnimationsManager animationsManager =
+        mContext
+            .get()
+            .getNativeModule(ReanimatedModule.class)
+            .getNodesManager()
+            .getAnimationsManager();
+
+    WeakReference<LayoutAnimations> weakLayoutAnimations = new WeakReference<>(LayoutAnimations);
+    animationsManager.setNativeMethods(
+        new NativeMethodsHolder() {
+          @Override
+          public void startAnimationForTag(int tag, String type, HashMap<String, Float> values) {
+            LayoutAnimations LayoutAnimations = weakLayoutAnimations.get();
+            if (LayoutAnimations != null) {
+              HashMap<String, String> preparedValues = new HashMap<>();
+              for (String key : values.keySet()) {
+                preparedValues.put(key, values.get(key).toString());
+              }
+              LayoutAnimations.startAnimationForTag(tag, type, preparedValues);
+            }
+          }
+
+          @Override
+          public void removeConfigForTag(int tag) {
+            LayoutAnimations LayoutAnimations = weakLayoutAnimations.get();
+            if (LayoutAnimations != null) {
+              LayoutAnimations.removeConfigForTag(tag);
+            }
+          }
+
+          @Override
+          public boolean isLayoutAnimationEnabled() {
+            return LayoutAnimations.isLayoutAnimationEnabled();
+          }
+        });
+  }
+}

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

@@ -0,0 +1,25 @@
+package com.swmansion.reanimated;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.common.UIManagerType;
+import com.facebook.react.fabric.FabricUIManager;
+
+class ReaCompatibility {
+    private FabricUIManager fabricUIManager;
+
+    public ReaCompatibility(ReactApplicationContext reactApplicationContext) {
+        fabricUIManager = (FabricUIManager) UIManagerHelper.getUIManager(reactApplicationContext, UIManagerType.FABRIC);
+    }
+
+    public void registerFabricEventListener(NodesManager nodeManager) {
+        if (fabricUIManager != null) {
+            fabricUIManager.getEventDispatcher().addListener(nodeManager);
+        }
+    }
+
+    public void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+        fabricUIManager.synchronouslyUpdateViewOnUIThread(viewTag, uiProps);
+    }
+}

package/android/src/main/cpp/NativeProxy.cpp

@@ -20,6 +20,13 @@
 #include "NativeProxy.h"
 #include "PlatformDepMethodsHolder.h"
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <JFabricUIManager.h>
+#include "FabricUtils.h"
+#include "NewestShadowNodesRegistry.h"
+#include "ReanimatedUIManagerBinding.h"
+#endif
+
 namespace reanimated {
 
 using namespace facebook;
@@ -30,18 +37,40 @@ NativeProxy::NativeProxy(
     jsi::Runtime *rt,
     std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
     std::shared_ptr<Scheduler> scheduler,
-    jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations)
+    jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+    ,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager
+#endif
+    )
     : javaPart_(jni::make_global(jThis)),
       runtime_(rt),
       jsCallInvoker_(jsCallInvoker),
-      scheduler_(scheduler),
-      layoutAnimations(std::move(_layoutAnimations)) {}
+      layoutAnimations(std::move(_layoutAnimations)),
+      scheduler_(scheduler)
+#ifdef RCT_NEW_ARCH_ENABLED
+      ,
+      newestShadowNodesRegistry_(std::make_shared<NewestShadowNodesRegistry>())
+#endif
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  Binding *binding = fabricUIManager->getBinding();
+  RuntimeExecutor runtimeExecutor = getRuntimeExecutorFromBinding(binding);
+  std::shared_ptr<UIManager> uiManager =
+      binding->getScheduler()->getUIManager();
+  ReanimatedUIManagerBinding::createAndInstallIfNeeded(
+      *rt, runtimeExecutor, uiManager, newestShadowNodesRegistry_);
+#endif
+}
 
 NativeProxy::~NativeProxy() {
   runtime_->global().setProperty(
       *runtime_,
       jsi::PropNameID::forAscii(*runtime_, "__reanimatedModuleProxy"),
       jsi::Value::undefined());
+  // removed temporary, new event listener mechanism need fix on the RN side
+  // reactScheduler_->removeEventListener(eventListener_);
 }
 
 jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
@@ -50,7 +79,13 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
     jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
         jsCallInvokerHolder,
     jni::alias_ref<AndroidScheduler::javaobject> androidScheduler,
-    jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations) {
+    jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+    ,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager
+#endif
+) {
   auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
   auto scheduler = androidScheduler->cthis()->getScheduler();
   scheduler->setJSCallInvoker(jsCallInvoker);
@@ -59,19 +94,43 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
       (jsi::Runtime *)jsContext,
       jsCallInvoker,
       scheduler,
-      make_global(layoutAnimations));
+      make_global(layoutAnimations)
+#ifdef RCT_NEW_ARCH_ENABLED
+          ,
+      fabricUIManager
+#endif
+      /**/);
 }
 
-void NativeProxy::installJSIBindings() {
-  auto propUpdater = [this](
-                         jsi::Runtime &rt,
-                         int viewTag,
-                         const jsi::Value &viewName,
-                         const jsi::Object &props) {
+void NativeProxy::installJSIBindings(
+#ifdef RCT_NEW_ARCH_ENABLED
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager
+#endif
+    /**/) {
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  auto updatePropsFunction = [this](
+                                 jsi::Runtime &rt,
+                                 int viewTag,
+                                 const jsi::Value &viewName,
+                                 const jsi::Object &props) {
     // viewName is for iOS only, we skip it here
     this->updateProps(rt, viewTag, props);
   };
 
+  auto measureFunction =
+      [this](int viewTag) -> std::vector<std::pair<std::string, double>> {
+    return measure(viewTag);
+  };
+
+  auto scrollToFunction =
+      [this](int viewTag, double x, double y, bool animated) -> void {
+    scrollTo(viewTag, x, y, animated);
+  };
+#endif
+
   auto getCurrentTime = [this]() {
     auto method =
         javaPart_->getClass()->getMethod<local_ref<JString>()>("getUptime");
@@ -99,6 +158,12 @@ void NativeProxy::installJSIBindings() {
     this->requestRender(std::move(wrappedOnRender));
   };
 
+#ifdef RCT_NEW_ARCH_ENABLED
+  auto synchronouslyUpdateUIPropsFunction =
+      [this](jsi::Runtime &rt, Tag tag, const jsi::Value &props) {
+        this->synchronouslyUpdateUIProps(rt, tag, props);
+      };
+#else
   auto propObtainer = [this](
                           jsi::Runtime &rt,
                           const int viewTag,
@@ -113,16 +178,7 @@ void NativeProxy::installJSIBindings() {
     std::string str = result->toStdString();
     return jsi::Value(rt, jsi::String::createFromAscii(rt, str.c_str()));
   };
-
-  auto measuringFunction =
-      [this](int viewTag) -> std::vector<std::pair<std::string, double>> {
-    return measure(viewTag);
-  };
-
-  auto scrollToFunction =
-      [this](int viewTag, double x, double y, bool animated) -> void {
-    scrollTo(viewTag, x, y, animated);
-  };
+#endif
 
   auto registerSensorFunction =
       [this](int sensorType, int interval, std::function<void(double[])> setter)
@@ -145,11 +201,25 @@ void NativeProxy::installJSIBindings() {
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       facebook::jsc::makeJSCRuntime();
 #endif
+  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>(animatedRuntime.get());
+
   runtime_->global().setProperty(
-      *runtime_,
-      "_WORKLET_RUNTIME",
-      static_cast<double>(
-          reinterpret_cast<std::uintptr_t>(animatedRuntime.get())));
+      *runtime_, "_WORKLET_RUNTIME", workletRuntimeValue);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  runtime_->global().setProperty(*runtime_, "_IS_FABRIC", true);
+#else
+  runtime_->global().setProperty(*runtime_, "_IS_FABRIC", false);
+#endif
 
   std::shared_ptr<ErrorHandler> errorHandler =
       std::make_shared<AndroidErrorHandler>(scheduler_);
@@ -180,26 +250,54 @@ void NativeProxy::installJSIBindings() {
 
   PlatformDepMethodsHolder platformDepMethodsHolder = {
       requestRender,
-      propUpdater,
+#ifdef RCT_NEW_ARCH_ENABLED
+      synchronouslyUpdateUIPropsFunction,
+#else
+      updatePropsFunction,
       scrollToFunction,
-      measuringFunction,
+      measureFunction,
+      configurePropsFunction,
+#endif
       getCurrentTime,
       registerSensorFunction,
       unregisterSensorFunction,
-      setGestureStateFunction,
-      configurePropsFunction};
+      setGestureStateFunction};
 
   auto module = std::make_shared<NativeReanimatedModule>(
       jsCallInvoker_,
       scheduler_,
       animatedRuntime,
       errorHandler,
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
       propObtainer,
+#endif
       layoutAnimationsProxy,
       platformDepMethodsHolder);
 
   _nativeReanimatedModule = module;
+
   std::weak_ptr<NativeReanimatedModule> weakModule = module;
+#ifdef RCT_NEW_ARCH_ENABLED
+  this->registerEventHandler([weakModule, getCurrentTime](
+                                 std::string eventName,
+                                 std::string eventAsString) {
+    if (auto module = weakModule.lock()) {
+      // handles RCTEvents from RNGestureHandler
+
+      std::string eventJSON = eventAsString.substr(
+          13, eventAsString.length() - 15); // removes "{ NativeMap: " and " }"
+      jsi::Runtime &rt = *module->runtime;
+      jsi::Value payload =
+          jsi::valueFromDynamic(rt, folly::parseJson(eventJSON));
+      // TODO: support NaN and INF values
+      // TODO: convert event directly to jsi::Value without JSON serialization
+
+      module->handleEvent(eventName, std::move(payload), getCurrentTime());
+    }
+  });
+#else
   this->registerEventHandler(
       [weakModule, getCurrentTime](
           std::string eventName, std::string eventAsString) {
@@ -214,6 +312,23 @@ void NativeProxy::installJSIBindings() {
               *module->runtime, eventTimestampName, jsi::Value::undefined());
         }
       });
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  Binding *binding = fabricUIManager->getBinding();
+  std::shared_ptr<UIManager> uiManager =
+      binding->getScheduler()->getUIManager();
+  module->setUIManager(uiManager);
+  module->setNewestShadowNodesRegistry(newestShadowNodesRegistry_);
+  newestShadowNodesRegistry_ = nullptr;
+#endif
+  //  removed temporary, new event listener mechanism need fix on the RN side
+  //  eventListener_ = std::make_shared<EventListener>(
+  //      [module, getCurrentTime](const RawEvent &rawEvent) {
+  //        return module->handleRawEvent(rawEvent, getCurrentTime());
+  //      });
+  //  reactScheduler_ = binding->getScheduler();
+  //  reactScheduler_->addEventListener(eventListener_);
 
   runtime_->global().setProperty(
       *runtime_,
@@ -225,13 +340,20 @@ bool NativeProxy::isAnyHandlerWaitingForEvent(std::string s) {
   return _nativeReanimatedModule->isAnyHandlerWaitingForEvent(s);
 }
 
+void NativeProxy::performOperations() {
+#ifdef RCT_NEW_ARCH_ENABLED
+  _nativeReanimatedModule->performOperations();
+#endif
+}
+
 void NativeProxy::registerNatives() {
   registerHybrid(
       {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
        makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
        makeNativeMethod(
            "isAnyHandlerWaitingForEvent",
-           NativeProxy::isAnyHandlerWaitingForEvent)});
+           NativeProxy::isAnyHandlerWaitingForEvent),
+       makeNativeMethod("performOperations", NativeProxy::performOperations)});
 }
 
 void NativeProxy::requestRender(std::function<void(double)> onRender) {
@@ -254,6 +376,9 @@ void NativeProxy::registerEventHandler(
       EventHandler::newObjectCxxArgs(std::move(handler)).get());
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else
 void NativeProxy::updateProps(
     jsi::Runtime &rt,
     int viewTag,
@@ -291,6 +416,27 @@ std::vector<std::pair<std::string, double>> NativeProxy::measure(int viewTag) {
 
   return result;
 }
+#endif // RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+inline jni::local_ref<ReadableMap::javaobject> castReadableMap(
+    jni::local_ref<ReadableNativeMap::javaobject> const &nativeMap) {
+  return make_local(reinterpret_cast<ReadableMap::javaobject>(nativeMap.get()));
+}
+
+void NativeProxy::synchronouslyUpdateUIProps(
+    jsi::Runtime &rt,
+    Tag tag,
+    const jsi::Value &props) {
+  static const auto method =
+      javaPart_->getClass()
+          ->getMethod<void(int, jni::local_ref<ReadableMap::javaobject>)>(
+              "synchronouslyUpdateUIProps");
+  jni::local_ref<ReadableMap::javaobject> uiProps = castReadableMap(
+      ReadableNativeMap::newObjectCxxArgs(jsi::dynamicFromValue(rt, props)));
+  method(javaPart_.get(), tag, uiProps);
+}
+#endif
 
 int NativeProxy::registerSensor(
     int sensorType,
@@ -326,11 +472,10 @@ void NativeProxy::configureProps(
                         ReadableNativeArray::javaobject)>("configureProps");
   method(
       javaPart_.get(),
-      ReadableNativeArray::newObjectCxxArgs(
-          std::move(jsi::dynamicFromValue(rt, uiProps)))
+      ReadableNativeArray::newObjectCxxArgs(jsi::dynamicFromValue(rt, uiProps))
           .get(),
       ReadableNativeArray::newObjectCxxArgs(
-          std::move(jsi::dynamicFromValue(rt, nativeProps)))
+          jsi::dynamicFromValue(rt, nativeProps))
           .get());
 }