react-native-reanimated 3.19.0 → 3.19.2

package/Common/cpp/reanimated/Fabric/PropsRegistry.cpp

@@ -24,10 +24,9 @@ void PropsRegistry::update(
   }
 }
 
-void PropsRegistry::for_each(
-    std::function<
-        void(const ShadowNodeFamily &family, const folly::dynamic &props)>
-        callback) const {
+void PropsRegistry::for_each(std::function<void(
+                                 const ShadowNodeFamily &family,
+                                 const folly::dynamic &props)> callback) const {
   for (const auto &[_, value] : map_) {
     callback(value.first->getFamily(), value.second);
   }
@@ -43,22 +42,21 @@ void PropsRegistry::unmarkNodeAsRemovable(Tag viewTag) {
 }
 
 void PropsRegistry::handleNodeRemovals(const RootShadowNode &rootShadowNode) {
-  for (auto it = removableShadowNodes_.begin();
-       it != removableShadowNodes_.end();) {
-    const auto &shadowNode = it->second;
-    const auto &family = shadowNode->getFamily();
-    const auto &ancestors = family.getAncestors(rootShadowNode);
+  RemovableShadowNodes remainingShadowNodes;
 
-    // Skip if the node hasn't been removed
-    if (!ancestors.empty()) {
-      ++it;
+  for (const auto &[tag, shadowNode] : removableShadowNodes_) {
+    if (!shadowNode) {
       continue;
     }
 
-    const auto tag = shadowNode->getTag();
-    map_.erase(tag);
-    it = removableShadowNodes_.erase(it);
+    if (shadowNode->getFamily().getAncestors(rootShadowNode).empty()) {
+      map_.erase(tag);
+    } else {
+      remainingShadowNodes.emplace(tag, shadowNode);
+    }
   }
+
+  removableShadowNodes_ = std::move(remainingShadowNodes);
 }
 
 void PropsRegistry::remove(const Tag tag) {

package/Common/cpp/reanimated/Fabric/PropsRegistry.h

@@ -4,6 +4,7 @@
 #include <react/renderer/components/root/RootShadowNode.h>
 #include <react/renderer/core/ShadowNode.h>
 
+#include <memory>
 #include <unordered_map>
 #include <utility>
 
@@ -21,10 +22,9 @@ class PropsRegistry {
       const std::shared_ptr<const ShadowNode> &shadowNode,
       folly::dynamic &&props);
 
-  void for_each(
-      std::function<
-          void(const ShadowNodeFamily &family, const folly::dynamic &props)>
-          callback) const;
+  void for_each(std::function<void(
+                    const ShadowNodeFamily &family,
+                    const folly::dynamic &props)> callback) const;
 
   void remove(const Tag tag);
 
@@ -57,12 +57,14 @@ class PropsRegistry {
   void handleNodeRemovals(const RootShadowNode &rootShadowNode);
 
  private:
+  using RemovableShadowNodes =
+      std::unordered_map<Tag, std::shared_ptr<const ShadowNode>>;
+
   std::unordered_map<
       Tag,
       std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>
       map_;
-  std::unordered_map<Tag, std::shared_ptr<const ShadowNode>>
-      removableShadowNodes_;
+  RemovableShadowNodes removableShadowNodes_;
 
   mutable std::mutex mutex_; // Protects `map_`.
 

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy.cpp

@@ -37,6 +37,9 @@ std::optional<MountingTransaction> LayoutAnimationsProxy::pullTransaction(
 
   addOngoingAnimations(surfaceId, filteredMutations);
 
+#ifdef ANDROID
+  restoreOpacityInCaseOfFlakyEnteringAnimation(surfaceId);
+#endif // ANDROID
   for (const auto tag : finishedAnimationTags_) {
     auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
     layoutAnimations_.erase(tag);
@@ -261,9 +264,8 @@ void LayoutAnimationsProxy::handleRemovals(
       node->unflattenedParent->removeChildFromUnflattenedTree(node); //???
       if (node->state != MOVED) {
         maybeCancelAnimation(node->tag);
-        filteredMutations.push_back(
-            ShadowViewMutation::DeleteMutation(
-                node->mutation.oldChildShadowView));
+        filteredMutations.push_back(ShadowViewMutation::DeleteMutation(
+            node->mutation.oldChildShadowView));
         nodeForTag_.erase(node->tag);
         node->state = DELETED;
 #ifdef LAYOUT_ANIMATIONS_LOGS
@@ -320,11 +322,10 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
           auto layoutAnimationIt = layoutAnimations_.find(tag);
           if (layoutAnimationIt == layoutAnimations_.end()) {
             if (oldShadowViewsForReparentings.contains(tag)) {
-              filteredMutations.push_back(
-                  ShadowViewMutation::InsertMutation(
-                      mutationParent,
-                      oldShadowViewsForReparentings[tag],
-                      mutation.index));
+              filteredMutations.push_back(ShadowViewMutation::InsertMutation(
+                  mutationParent,
+                  oldShadowViewsForReparentings[tag],
+                  mutation.index));
             } else {
               filteredMutations.push_back(mutation);
             }
@@ -332,9 +333,8 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
           }
 
           auto oldView = *layoutAnimationIt->second.currentView;
-          filteredMutations.push_back(
-              ShadowViewMutation::InsertMutation(
-                  mutationParent, oldView, mutation.index));
+          filteredMutations.push_back(ShadowViewMutation::InsertMutation(
+              mutationParent, oldView, mutation.index));
           if (movedViews.contains(tag)) {
             layoutAnimationIt->second.parentTag = movedViews.at(tag);
           }
@@ -356,9 +356,8 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
         std::shared_ptr<ShadowView> newView =
             cloneViewWithoutOpacity(mutation, propsParserContext);
 
-        filteredMutations.push_back(
-            ShadowViewMutation::UpdateMutation(
-                mutation.newChildShadowView, *newView, mutationParent));
+        filteredMutations.push_back(ShadowViewMutation::UpdateMutation(
+            mutation.newChildShadowView, *newView, mutationParent));
         break;
       }
 
@@ -407,7 +406,36 @@ void LayoutAnimationsProxy::addOngoingAnimations(
     SurfaceId surfaceId,
     ShadowViewMutationList &mutations) const {
   auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
+#ifdef ANDROID
+  std::vector<int> tagsToUpdate;
   for (auto &[tag, updateValues] : updateMap) {
+    tagsToUpdate.push_back(tag);
+  }
+
+  auto maybeCorrectedTags = preserveMountedTags_(tagsToUpdate);
+  if (!maybeCorrectedTags.has_value()) {
+    return;
+  }
+
+  auto correctedTags = maybeCorrectedTags->get();
+
+  // since the map is not updated, we can assume that the ordering of tags in
+  // correctedTags matches the iterator
+  int i = -1;
+#endif
+  for (auto &[tag, updateValues] : updateMap) {
+#ifdef ANDROID
+    i++;
+    if (correctedTags[i] == -1) {
+      // skip views that have not been mounted yet
+      // on Android we start entering animations from the JS thread
+      // so it might happen, that the first frame of the animation goes through
+      // before the view is first mounted
+      // https://github.com/software-mansion/react-native-reanimated/issues/7493
+      continue;
+    }
+#endif
+
     auto layoutAnimationIt = layoutAnimations_.find(tag);
 
     if (layoutAnimationIt == layoutAnimations_.end()) {
@@ -415,21 +443,20 @@ void LayoutAnimationsProxy::addOngoingAnimations(
     }
 
     auto &layoutAnimation = layoutAnimationIt->second;
-
+    layoutAnimation.isViewAlreadyMounted = true;
     auto newView = std::make_shared<ShadowView>(*layoutAnimation.finalView);
     newView->props = updateValues.newProps;
     updateLayoutMetrics(newView->layoutMetrics, updateValues.frame);
 
-    mutations.push_back(
-        ShadowViewMutation::UpdateMutation(
-            *layoutAnimation.currentView,
-            *newView,
+    mutations.push_back(ShadowViewMutation::UpdateMutation(
+        *layoutAnimation.currentView,
+        *newView,
 #if REACT_NATIVE_MINOR_VERSION >= 78
-            layoutAnimation.parentTag
+        layoutAnimation.parentTag
 #else
-            *layoutAnimation.parentView
+        *layoutAnimation.parentView
 #endif // REACT_NATIVE_MINOR_VERSION >= 78
-            ));
+        ));
     layoutAnimation.currentView = newView;
   }
   updateMap.clear();
@@ -554,9 +581,8 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
 #ifdef LAYOUT_ANIMATIONS_LOGS
       LOG(INFO) << "delete " << subNode->tag << std::endl;
 #endif
-      mutations.push_back(
-          ShadowViewMutation::DeleteMutation(
-              subNode->mutation.oldChildShadowView));
+      mutations.push_back(ShadowViewMutation::DeleteMutation(
+          subNode->mutation.oldChildShadowView));
     } else {
       subNode->state = WAITING;
     }
@@ -654,11 +680,13 @@ void LayoutAnimationsProxy::createLayoutAnimation(
 #if REACT_NATIVE_MINOR_VERSION >= 78
   layoutAnimations_.insert_or_assign(
       tag,
-      LayoutAnimation{finalView, currentView, mutation.parentTag, {}, count});
+      LayoutAnimation{
+          finalView, currentView, mutation.parentTag, {}, false, count});
 #else
   auto parentView = std::make_shared<ShadowView>(mutation.parentShadowView);
   layoutAnimations_.insert_or_assign(
-      tag, LayoutAnimation{finalView, currentView, parentView, {}, count});
+      tag,
+      LayoutAnimation{finalView, currentView, parentView, {}, false, count});
 #endif // REACT_NATIVE_MINOR_VERSION >= 78
 }
 
@@ -697,16 +725,15 @@ void LayoutAnimationsProxy::startEnteringAnimation(
       auto &mutex = strongThis->mutex;
       auto lock = std::unique_lock<std::recursive_mutex>(mutex);
       strongThis->layoutAnimations_.insert_or_assign(
-          tag,
-          LayoutAnimation{
-              finalView,
-              current,
+          tag, LayoutAnimation {
+            finalView, current,
 #if REACT_NATIVE_MINOR_VERSION >= 78
-              mutation.parentTag,
+                mutation.parentTag,
 #else
               parent,
 #endif // REACT_NATIVE_MINOR_VERSION >= 78
-              opacity});
+                opacity
+          });
       window = strongThis->surfaceManager.getWindow(
           mutation.newChildShadowView.surfaceId);
     }
@@ -877,7 +904,12 @@ void LayoutAnimationsProxy::maybeRestoreOpacity(
   if (layoutAnimation.opacity && !newStyle.hasProperty(uiRuntime_, "opacity")) {
     newStyle.setProperty(
         uiRuntime_, "opacity", jsi::Value(*layoutAnimation.opacity));
-    layoutAnimation.opacity.reset();
+    if (layoutAnimation.isViewAlreadyMounted) {
+      // We want to reset opacity only when we are sure that this update will be
+      // applied to the native view. Otherwise, we want to update opacity using
+      // the `restoreOpacityInCaseOfFlakyEnteringAnimation` method.
+      layoutAnimation.opacity.reset();
+    }
   }
 }
 
@@ -894,6 +926,78 @@ void LayoutAnimationsProxy::maybeUpdateWindowDimensions(
   }
 }
 
+#ifdef ANDROID
+/*
+ * It is possible that we may finish the layout animation before the native view
+ * is mounted. If the view wasn't mounted, we wouldn't be able to restore the
+ * opacity of the view. To fix this, we need to schedule a React update that
+ * will restore the view's opacity. This is safe because we'll use the same
+ * queue where React has already scheduled (but not yet executed) the view
+ * mounting, so the opacity update will execute after the view is mounted.
+ */
+void LayoutAnimationsProxy::restoreOpacityInCaseOfFlakyEnteringAnimation(
+    SurfaceId surfaceId) const {
+  std::vector<std::pair<double, Tag>> opacityToRestore;
+  for (const auto tag : finishedAnimationTags_) {
+    const auto &opacity = layoutAnimations_[tag].opacity;
+    if (opacity.has_value()) {
+      opacityToRestore.emplace_back(
+          std::pair<double, Tag>{opacity.value(), tag});
+    }
+  }
+  if (opacityToRestore.empty()) {
+    // Animation was successfully finished, and the opacity was restored, so we
+    // don't need to do anything. Only the Entering animation has a set opacity
+    // value.
+    return;
+  }
+  const auto weakThis = weak_from_this();
+  jsInvoker_->invokeAsync([=](jsi::Runtime &runtime) {
+    const auto self = weakThis.lock();
+    if (!self) {
+      return;
+    }
+    self->uiManager_->getShadowTreeRegistry().visit(
+        surfaceId, [=](ShadowTree const &shadowTree) {
+          shadowTree.commit(
+              [=](RootShadowNode const &oldRootShadowNode) {
+                const auto self = weakThis.lock();
+                if (!self) {
+                  return cloneShadowTreeWithNewProps(oldRootShadowNode, {});
+                }
+                const auto &rootShadowNode =
+                    static_cast<const ShadowNode &>(oldRootShadowNode);
+                PropsMap propsMap;
+                for (const auto &[opacity, tag] : opacityToRestore) {
+                  const auto *targetShadowNode =
+                      self->findInShadowTreeByTag(rootShadowNode, tag);
+                  if (targetShadowNode != nullptr) {
+                    propsMap[&targetShadowNode->getFamily()].emplace_back(
+                        folly::dynamic::object("opacity", opacity));
+                  }
+                }
+                return cloneShadowTreeWithNewProps(oldRootShadowNode, propsMap);
+              },
+              {});
+        });
+  });
+}
+
+const ShadowNode *LayoutAnimationsProxy::findInShadowTreeByTag(
+    const ShadowNode &node,
+    Tag tag) const {
+  if (node.getTag() == tag) {
+    return const_cast<const ShadowNode *>(&node);
+  }
+  for (auto &child : node.getChildren()) {
+    if (const auto result = findInShadowTreeByTag(*child, tag)) {
+      return result;
+    }
+  }
+  return nullptr;
+}
+#endif // ANDROID
+
 } // namespace reanimated
 
 #endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy.h

@@ -4,12 +4,15 @@
 #include <reanimated/Fabric/PropsRegistry.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
 
 #include <worklets/Tools/UIScheduler.h>
 
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/ShadowView.h>
+#include <react/renderer/scheduler/Scheduler.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
 
 #include <memory>
 #include <string>
@@ -31,6 +34,7 @@ struct LayoutAnimation {
   std::shared_ptr<ShadowView> finalView, currentView, parentView;
 #endif // REACT_NATIVE_MINOR_VERSION >= 78
   std::optional<double> opacity;
+  bool isViewAlreadyMounted = false;
   int count = 1;
   LayoutAnimation &operator=(const LayoutAnimation &other) = default;
 };
@@ -50,17 +54,38 @@ struct LayoutAnimationsProxy
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
   jsi::Runtime &uiRuntime_;
   const std::shared_ptr<UIScheduler> uiScheduler_;
+#ifdef ANDROID
+  PreserveMountedTagsFunction preserveMountedTags_;
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+#endif
+
   LayoutAnimationsProxy(
       std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager,
       SharedComponentDescriptorRegistry componentDescriptorRegistry,
       ContextContainer::Shared contextContainer,
       jsi::Runtime &uiRuntime,
-      const std::shared_ptr<UIScheduler> uiScheduler)
+      const std::shared_ptr<UIScheduler> uiScheduler
+#ifdef ANDROID
+      ,
+      PreserveMountedTagsFunction filterUnmountedTagsFunction,
+      std::shared_ptr<UIManager> uiManager,
+      std::shared_ptr<CallInvoker> jsInvoker
+#endif
+      )
       : layoutAnimationsManager_(layoutAnimationsManager),
         contextContainer_(contextContainer),
         componentDescriptorRegistry_(componentDescriptorRegistry),
         uiRuntime_(uiRuntime),
-        uiScheduler_(uiScheduler) {}
+        uiScheduler_(uiScheduler)
+#ifdef ANDROID
+        ,
+        preserveMountedTags_(filterUnmountedTagsFunction),
+        uiManager_(uiManager),
+        jsInvoker_(jsInvoker)
+#endif // ANDROID
+  {
+  }
 
   void startEnteringAnimation(const int tag, ShadowViewMutation &mutation)
       const;
@@ -132,7 +157,11 @@ struct LayoutAnimationsProxy
 
   const ComponentDescriptor &getComponentDescriptorForShadowView(
       const ShadowView &shadowView) const;
-
+#ifdef ANDROID
+  void restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const;
+  const ShadowNode *findInShadowTreeByTag(const ShadowNode &node, Tag tag)
+      const;
+#endif // ANDROID
   // MountingOverrideDelegate
 
   bool shouldOverridePullTransaction() const override;

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp

@@ -36,6 +36,7 @@
 
 namespace reanimated {
 
+#ifdef RCT_NEW_ARCH_ENABLED
 #if REACT_NATIVE_MINOR_VERSION >= 81
 static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
     jsi::Runtime &rt,
@@ -43,7 +44,8 @@ static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
   return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
       rt, shadowNodeWrapper);
 }
-#endif
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+#endif // RCT_NEW_ARCH_ENABLED
 
 ReanimatedModuleProxy::ReanimatedModuleProxy(
     const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy,
@@ -57,14 +59,13 @@ ReanimatedModuleProxy::ReanimatedModuleProxy(
       isReducedMotion_(isReducedMotion),
       workletsModuleProxy_(workletsModuleProxy),
       valueUnpackerCode_(workletsModuleProxy->getValueUnpackerCode()),
-      uiWorkletRuntime_(
-          std::make_shared<WorkletRuntime>(
-              rnRuntime,
-              workletsModuleProxy->getJSQueue(),
-              workletsModuleProxy->getJSScheduler(),
-              "Reanimated UI runtime",
-              true /* supportsLocking */,
-              valueUnpackerCode_)),
+      uiWorkletRuntime_(std::make_shared<WorkletRuntime>(
+          rnRuntime,
+          workletsModuleProxy->getJSQueue(),
+          workletsModuleProxy->getJSScheduler(),
+          "Reanimated UI runtime",
+          true /* supportsLocking */,
+          valueUnpackerCode_)),
       eventHandlerRegistry_(std::make_unique<EventHandlerRegistry>()),
       requestRender_(platformDepMethodsHolder.requestRender),
       animatedSensorModule_(platformDepMethodsHolder),
@@ -73,6 +74,10 @@ ReanimatedModuleProxy::ReanimatedModuleProxy(
       layoutAnimationsManager_(
           std::make_shared<LayoutAnimationsManager>(jsLogger_)),
 #ifdef RCT_NEW_ARCH_ENABLED
+#ifdef ANDROID
+      filterUnmountedTagsFunction_(
+          platformDepMethodsHolder.filterUnmountedTagsFunction),
+#endif // ANDROID
       propsRegistry_(std::make_shared<PropsRegistry>()),
 #else
       obtainPropFunction_(platformDepMethodsHolder.obtainPropFunction),
@@ -410,10 +415,9 @@ std::string ReanimatedModuleProxy::obtainPropFromShadowNode(
     }
   }
 
-  throw std::runtime_error(
-      std::string(
-          "Getting property `" + propName +
-          "` with function `getViewProp` is not supported"));
+  throw std::runtime_error(std::string(
+      "Getting property `" + propName +
+      "` with function `getViewProp` is not supported"));
 }
 
 jsi::Value ReanimatedModuleProxy::getViewProp(
@@ -621,6 +625,7 @@ void ReanimatedModuleProxy::cleanupSensors() {
 void ReanimatedModuleProxy::markNodeAsRemovable(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeWrapper) {
+  auto lock = propsRegistry_->createLock();
   auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
   propsRegistry_->markNodeAsRemovable(shadowNode);
 }
@@ -628,6 +633,7 @@ void ReanimatedModuleProxy::markNodeAsRemovable(
 void ReanimatedModuleProxy::unmarkNodeAsRemovable(
     jsi::Runtime &rt,
     const jsi::Value &viewTag) {
+  auto lock = propsRegistry_->createLock();
   propsRegistry_->unmarkNodeAsRemovable(viewTag.asNumber());
 }
 
@@ -941,7 +947,14 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
         componentDescriptorRegistry,
         scheduler->getContextContainer(),
         uiWorkletRuntime_->getJSIRuntime(),
-        workletsModuleProxy_->getUIScheduler());
+        workletsModuleProxy_->getUIScheduler()
+#ifdef ANDROID
+            ,
+        filterUnmountedTagsFunction_,
+        uiManager_,
+        jsInvoker_
+#endif
+    );
   }
 }
 

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h

@@ -223,6 +223,9 @@ class ReanimatedModuleProxy
   std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
 
 #ifdef RCT_NEW_ARCH_ENABLED
+#ifdef ANDROID
+  const PreserveMountedTagsFunction filterUnmountedTagsFunction_;
+#endif // ANDROID
   std::unordered_set<std::string>
       animatablePropNames_; // filled by configureProps
   std::shared_ptr<UIManager> uiManager_;

package/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h

@@ -6,6 +6,8 @@
 #include <react/renderer/core/ReactPrimitives.h>
 #endif
 
+#include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -53,6 +55,10 @@ using ObtainPropFunction =
 
 using RequestRenderFunction =
     std::function<void(std::function<void(const double)>)>;
+#ifdef ANDROID
+using PreserveMountedTagsFunction =
+    std::function<std::optional<std::unique_ptr<int[]>>(std::vector<int> &)>;
+#endif // ANDROID
 using GetAnimationTimestampFunction = std::function<double(void)>;
 
 using ProgressLayoutAnimationFunction =
@@ -75,7 +81,9 @@ using MaybeFlushUIUpdatesQueueFunction = std::function<void()>;
 struct PlatformDepMethodsHolder {
   RequestRenderFunction requestRender;
 #ifdef RCT_NEW_ARCH_ENABLED
-  // nothing
+#ifdef ANDROID
+  PreserveMountedTagsFunction filterUnmountedTagsFunction;
+#endif // ANDROID
 #else
   UpdatePropsFunction updatePropsFunction;
   ScrollToFunction scrollToFunction;

package/android/CMakeLists.txt

@@ -15,9 +15,16 @@ string(APPEND CMAKE_CXX_FLAGS
        " -DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}\
    -DREANIMATED_VERSION=${REANIMATED_VERSION}")
 
-string(APPEND CMAKE_CXX_FLAGS
-       " -fexceptions -fno-omit-frame-pointer -frtti -fstack-protector-all\
-   -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
+string(APPEND CMAKE_CXX_FLAGS " -fno-omit-frame-pointer -fstack-protector-all")
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
+  include("${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/\
+react-native-flags.cmake")
+  target_compile_reactnative_options(reanimated PUBLIC)
+else()
+  string(APPEND CMAKE_CXX_FLAGS
+         " -fexceptions -frtti -std=c++${CMAKE_CXX_STANDARD} -Wall -Werror")
+endif()
 
 if(${IS_NEW_ARCHITECTURE_ENABLED})
   string(APPEND CMAKE_CXX_FLAGS " -DRCT_NEW_ARCH_ENABLED")

package/android/build.gradle

@@ -332,8 +332,8 @@ android {
         extractSO
     }
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
     }
     sourceSets.main {
         java {
@@ -380,7 +380,7 @@ android {
 
 def assertMinimalReactNativeVersion = task assertMinimalReactNativeVersionTask {
     // If you change the minimal React Native version remember to update Compatibility Table in docs
-    def minimalReactNativeVersion = 75
+    def minimalReactNativeVersion = 78
     onlyIf { REACT_NATIVE_MINOR_VERSION < minimalReactNativeVersion }
     doFirst {
         throw new GradleException("[Reanimated] Unsupported React Native version. Please use $minimalReactNativeVersion. or newer.")

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

@@ -4,6 +4,7 @@ import androidx.annotation.OptIn;
 import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.annotations.FrameworkAPI;
 import com.facebook.react.fabric.FabricUIManager;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
@@ -32,6 +33,8 @@ public class NativeProxy extends NativeProxyCommon {
    */
   private final AtomicBoolean mInvalidated = new AtomicBoolean(false);
 
+  private final FabricUIManager mFabricUIManager;
+
   public @OptIn(markerClass = FrameworkAPI.class) NativeProxy(
       ReactApplicationContext context, WorkletsModule workletsModule) {
     super(context);
@@ -39,6 +42,7 @@ public class NativeProxy extends NativeProxyCommon {
 
     FabricUIManager fabricUIManager =
         (FabricUIManager) UIManagerHelper.getUIManager(context, UIManagerType.FABRIC);
+    mFabricUIManager = fabricUIManager;
 
     LayoutAnimations LayoutAnimations = new LayoutAnimations(context);
 
@@ -72,6 +76,21 @@ public class NativeProxy extends NativeProxyCommon {
 
   public native void performOperations();
 
+  @DoNotStrip
+  public boolean preserveMountedTags(int[] tags) {
+    if (!UiThreadUtil.isOnUiThread()) {
+      return false;
+    }
+
+    for (int i = 0; i < tags.length; i++) {
+      if (mFabricUIManager.resolveView(tags[i]) == null) {
+        tags[i] = -1;
+      }
+    }
+
+    return true;
+  }
+
   @Override
   protected HybridData getHybridData() {
     return mHybridData;