react-native-screens 3.31.1 → 3.33.0

package/common/cpp/react/renderer/components/rnscreens/RNSModalScreenComponentDescriptor.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <react/debug/react_native_assert.h>
-#include "RNSModalScreenShadowNode.h"
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSModalScreenShadowNode.h"
 
 namespace facebook {
 namespace react {
@@ -12,16 +12,15 @@ class RNSModalScreenComponentDescriptor final
  public:
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
 
-  void adopt(ShadowNode& shadowNode) const override {
-    react_native_assert(
-        dynamic_cast<RNSModalScreenShadowNode*>(&shadowNode));
-    auto& screenShadowNode =
-        static_cast<RNSModalScreenShadowNode&>(shadowNode);
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(dynamic_cast<RNSModalScreenShadowNode *>(&shadowNode));
+    auto &screenShadowNode =
+        static_cast<RNSModalScreenShadowNode &>(shadowNode);
 
     react_native_assert(
-        dynamic_cast<YogaLayoutableShadowNode*>(&screenShadowNode));
-    auto& layoutableShadowNode =
-        dynamic_cast<YogaLayoutableShadowNode&>(screenShadowNode);
+        dynamic_cast<YogaLayoutableShadowNode *>(&screenShadowNode));
+    auto &layoutableShadowNode =
+        dynamic_cast<YogaLayoutableShadowNode &>(screenShadowNode);
 
     auto state =
         std::static_pointer_cast<const RNSModalScreenShadowNode::ConcreteState>(

package/common/cpp/react/renderer/components/rnscreens/RNSModalScreenShadowNode.cpp

@@ -5,7 +5,8 @@ namespace react {
 
 extern const char RNSModalScreenComponentName[] = "RNSModalScreen";
 
-Point RNSModalScreenShadowNode::getContentOriginOffset() const {
+Point RNSModalScreenShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
   auto stateData = getStateData();
   auto contentOffset = stateData.contentOffset;
   return {contentOffset.x, contentOffset.y};

package/common/cpp/react/renderer/components/rnscreens/RNSModalScreenShadowNode.h

@@ -1,25 +1,26 @@
 #pragma once
 
-#include "RNSScreenState.h"
+#include <jsi/jsi.h>
 #include <react/renderer/components/rnscreens/EventEmitters.h>
 #include <react/renderer/components/rnscreens/Props.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
-#include <jsi/jsi.h>
+#include "RNSScreenState.h"
 
 namespace facebook {
 namespace react {
 
 JSI_EXPORT extern const char RNSModalScreenComponentName[];
 
-class JSI_EXPORT RNSModalScreenShadowNode final : public ConcreteViewShadowNode<
-                                          RNSModalScreenComponentName,
-                                          RNSScreenProps,
-                                          RNSScreenEventEmitter,
-                                          RNSScreenState> {
+class JSI_EXPORT RNSModalScreenShadowNode final
+    : public ConcreteViewShadowNode<
+          RNSModalScreenComponentName,
+          RNSScreenProps,
+          RNSScreenEventEmitter,
+          RNSScreenState> {
  public:
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
 
-  Point getContentOriginOffset() const override;
+  Point getContentOriginOffset(bool includeTransform) const override;
   static ShadowNodeTraits BaseTraits() {
     auto traits = ConcreteViewShadowNode::BaseTraits();
     traits.set(ShadowNodeTraits::Trait::RootNodeKind);

package/common/cpp/react/renderer/components/rnscreens/RNSScreenComponentDescriptor.h

@@ -1,40 +1,177 @@
 #pragma once
 
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#endif
 #include <react/debug/react_native_assert.h>
-#include "RNSScreenShadowNode.h"
+#include <react/renderer/components/rnscreens/Props.h>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSScreenShadowNode.h"
+#include "utils/RectUtil.h"
 
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 class RNSScreenComponentDescriptor final
     : public ConcreteComponentDescriptor<RNSScreenShadowNode> {
  public:
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
 
-  void adopt(ShadowNode& shadowNode) const override {
-    react_native_assert(
-        dynamic_cast<RNSScreenShadowNode*>(&shadowNode));
-    auto& screenShadowNode =
-        static_cast<RNSScreenShadowNode&>(shadowNode);
+  static constexpr const char *kScreenDummyLayoutHelperClass =
+      "com/swmansion/rnscreens/utils/ScreenDummyLayoutHelper";
+
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(dynamic_cast<RNSScreenShadowNode *>(&shadowNode));
+    auto &screenShadowNode = static_cast<RNSScreenShadowNode &>(shadowNode);
 
     react_native_assert(
-        dynamic_cast<YogaLayoutableShadowNode*>(&screenShadowNode));
-    auto& layoutableShadowNode =
-        dynamic_cast<YogaLayoutableShadowNode&>(screenShadowNode);
+        dynamic_cast<YogaLayoutableShadowNode *>(&screenShadowNode));
+    auto &layoutableShadowNode =
+        dynamic_cast<YogaLayoutableShadowNode &>(screenShadowNode);
 
     auto state =
         std::static_pointer_cast<const RNSScreenShadowNode::ConcreteState>(
             shadowNode.getState());
     auto stateData = state->getData();
 
+#ifdef ANDROID
     if (stateData.frameSize.width != 0 && stateData.frameSize.height != 0) {
+      // When we receive dimensions from JVM side we can remove padding used for
+      // correction, and we can stop applying height correction for the frame.
+      // We want to leave top offset correction though intact.
+      // TODO: In future, when we have dynamic header height we might want to
+      // update Y offset correction here.
+
+#ifdef REACT_NATIVE_DEBUG
+      // We use the fact that height correction is disabled once we receive
+      // state from the native, so when we have incoming state & height
+      // correction is still enabled, we know this is the very first native
+      // state update.
+      if (screenShadowNode.getFrameCorrectionModes().check(
+              FrameCorrectionModes::Mode::FrameHeightCorrection) &&
+          !checkFrameSizesEqualWithEps(
+              screenShadowNode.layoutMetrics_.frame.size,
+              stateData.frameSize)) {
+        LOG(ERROR)
+            << "[RNScreens] The first frame received from state update: "
+            << stateData.frameSize.width << "x" << stateData.frameSize.height
+            << " differs from the one expected: "
+            << screenShadowNode.layoutMetrics_.frame.size.width << "x"
+            << screenShadowNode.layoutMetrics_.frame.size.height
+            << ". This is most likely a react-native-screens library bug. Please report this at https://github.com/software-mansion/react-native-screens/issues";
+      }
+#endif
+
+      screenShadowNode.setPadding({0, 0, 0, 0});
+      screenShadowNode.getFrameCorrectionModes().unset(
+          FrameCorrectionModes::Mode::FrameHeightCorrection);
+
       layoutableShadowNode.setSize(
           Size{stateData.frameSize.width, stateData.frameSize.height});
-    }
+    } else {
+      // This code path should be executed only on the very first (few)
+      // layout(s), when we haven't received state update from JVM side yet.
+
+      auto headerConfigChildOpt = findHeaderConfigChild(layoutableShadowNode);
 
+      // During creation of the shadow node children are not attached yet.
+      // We also do not want to set any padding in case.
+      if (headerConfigChildOpt) {
+        const auto &headerConfigChild = headerConfigChildOpt->get();
+        const auto &headerProps =
+            *std::static_pointer_cast<const RNSScreenStackHeaderConfigProps>(
+                headerConfigChild->getProps());
+
+        const auto headerHeight = headerProps.hidden
+            ? 0.f
+            : findHeaderHeight(
+                  headerProps.titleFontSize, headerProps.title.empty())
+                  .value_or(0.f);
+
+        screenShadowNode.setPadding({0, 0, 0, headerHeight});
+        screenShadowNode.setHeaderHeight(headerHeight);
+        screenShadowNode.getFrameCorrectionModes().set(
+            FrameCorrectionModes::Mode(
+                FrameCorrectionModes::Mode::FrameHeightCorrection |
+                FrameCorrectionModes::Mode::FrameOriginCorrection));
+      }
+    }
+#else
+    if (stateData.frameSize.width != 0 && stateData.frameSize.height != 0) {
+      layoutableShadowNode.setSize(
+          Size{stateData.frameSize.width, stateData.frameSize.height});
+    }
+#endif // ANDROID
     ConcreteComponentDescriptor::adopt(shadowNode);
   }
+
+  std::optional<std::reference_wrapper<const ShadowNode::Shared>>
+  findHeaderConfigChild(
+      const YogaLayoutableShadowNode &screenShadowNode) const {
+    for (const ShadowNode::Shared &child : screenShadowNode.getChildren()) {
+      if (std::strcmp(
+              child->getComponentName(), "RNSScreenStackHeaderConfig") == 0) {
+        return {std::cref(child)};
+      }
+    }
+    return {};
+  }
+
+#ifdef ANDROID
+  std::optional<float> findHeaderHeight(
+      const int fontSize,
+      const bool isTitleEmpty) const {
+    JNIEnv *env = facebook::jni::Environment::current();
+
+    if (env == nullptr) {
+      LOG(ERROR) << "[RNScreens] Failed to retrieve env\n";
+      return {};
+    }
+
+    jclass layoutHelperClass = env->FindClass(kScreenDummyLayoutHelperClass);
+
+    if (layoutHelperClass == nullptr) {
+      LOG(ERROR) << "[RNScreens] Failed to find class with id "
+                 << kScreenDummyLayoutHelperClass;
+      return {};
+    }
+
+    jmethodID computeDummyLayoutID =
+        env->GetMethodID(layoutHelperClass, "computeDummyLayout", "(IZ)F");
+
+    if (computeDummyLayoutID == nullptr) {
+      LOG(ERROR)
+          << "[RNScreens] Failed to retrieve computeDummyLayout method ID";
+      return {};
+    }
+
+    jmethodID getInstanceMethodID = env->GetStaticMethodID(
+        layoutHelperClass,
+        "getInstance",
+        "()Lcom/swmansion/rnscreens/utils/ScreenDummyLayoutHelper;");
+
+    if (getInstanceMethodID == nullptr) {
+      LOG(ERROR) << "[RNScreens] Failed to retrieve getInstanceMethodID";
+      return {};
+    }
+
+    jobject packageInstance =
+        env->CallStaticObjectMethod(layoutHelperClass, getInstanceMethodID);
+
+    if (packageInstance == nullptr) {
+      LOG(ERROR)
+          << "[RNScreens] Failed to retrieve packageInstance or the package instance was null on JVM side";
+      return {};
+    }
+
+    jfloat headerHeight = env->CallFloatMethod(
+        packageInstance, computeDummyLayoutID, fontSize, isTitleEmpty);
+
+    return {headerHeight};
+  }
+#endif // ANDROID
 };
 
 } // namespace react

package/common/cpp/react/renderer/components/rnscreens/RNSScreenShadowNode.cpp

@@ -3,13 +3,63 @@
 namespace facebook {
 namespace react {
 
+namespace yoga = facebook::yoga;
+using namespace rnscreens;
+
 extern const char RNSScreenComponentName[] = "RNSScreen";
 
-Point RNSScreenShadowNode::getContentOriginOffset() const {
+Point RNSScreenShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
   auto stateData = getStateData();
   auto contentOffset = stateData.contentOffset;
   return {contentOffset.x, contentOffset.y};
 }
 
+void RNSScreenShadowNode::layout(facebook::react::LayoutContext layoutContext) {
+  YogaLayoutableShadowNode::layout(layoutContext);
+
+#ifdef ANDROID
+  applyFrameCorrections();
+#endif // ANDROID
+}
+
+#ifdef ANDROID
+void RNSScreenShadowNode::applyFrameCorrections() {
+  ensureUnsealed();
+
+  // On the very first layout we want to correct both Y offset and frame size.
+  // On consecutive layouts we want to correct only Y offset, as the frame size
+  // is received from JVM side. This is done so if the Screen dimensions are
+  // read from ShadowTree (e.g by reanimated) they have chance of being
+  // accurate. On JVM side we do ignore this frame anyway, because
+  // ScreenStackViewManager.needsCustomLayoutForChildren() == true.
+  const auto &stateData = getStateData();
+  const float lastKnownHeaderHeight = stateData.getLastKnownHeaderHeight();
+  const auto &headerCorrectionModes = stateData.getHeaderCorrectionModes();
+  layoutMetrics_.frame.origin.y += lastKnownHeaderHeight *
+      headerCorrectionModes.check(
+          FrameCorrectionModes::Mode::FrameOriginCorrection);
+  layoutMetrics_.frame.size.height -= lastKnownHeaderHeight *
+      headerCorrectionModes.check(
+          FrameCorrectionModes::Mode::FrameHeightCorrection);
+}
+
+void RNSScreenShadowNode::setHeaderHeight(float headerHeight) {
+  getStateDataMutable().setHeaderHeight(headerHeight);
+}
+
+FrameCorrectionModes &RNSScreenShadowNode::getFrameCorrectionModes() {
+  return getStateDataMutable().getFrameCorrectionModes();
+}
+
+RNSScreenShadowNode::StateData &RNSScreenShadowNode::getStateDataMutable() {
+  // We assume that this method is called to mutate the data, so we ensure
+  // we're unsealed.
+  ensureUnsealed();
+  return const_cast<RNSScreenShadowNode::StateData &>(getStateData());
+}
+
+#endif // ANDROID
+
 } // namespace react
 } // namespace facebook

package/common/cpp/react/renderer/components/rnscreens/RNSScreenShadowNode.h

@@ -1,25 +1,47 @@
 #pragma once
 
-#include "RNSScreenState.h"
+#include <jsi/jsi.h>
 #include <react/renderer/components/rnscreens/EventEmitters.h>
 #include <react/renderer/components/rnscreens/Props.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
-#include <jsi/jsi.h>
+#include <react/renderer/core/LayoutContext.h>
+#include "FrameCorrectionModes.h"
+#include "RNSScreenState.h"
 
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 JSI_EXPORT extern const char RNSScreenComponentName[];
 
 class JSI_EXPORT RNSScreenShadowNode final : public ConcreteViewShadowNode<
-                                          RNSScreenComponentName,
-                                          RNSScreenProps,
-                                          RNSScreenEventEmitter,
-                                          RNSScreenState> {
+                                                 RNSScreenComponentName,
+                                                 RNSScreenProps,
+                                                 RNSScreenEventEmitter,
+                                                 RNSScreenState> {
  public:
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  using StateData = ConcreteViewShadowNode::ConcreteStateData;
+
+#pragma mark - ShadowNode overrides
+
+  Point getContentOriginOffset(bool includeTransform) const override;
+
+  void layout(LayoutContext layoutContext) override;
+
+#pragma mark - Custom interface
+
+  void setHeaderHeight(float headerHeight);
+
+  FrameCorrectionModes &getFrameCorrectionModes();
+
+ private:
+#ifdef ANDROID
+  void applyFrameCorrections();
 
-  Point getContentOriginOffset() const override;
+  StateData &getStateDataMutable();
+#endif // ANDROID
 };
 
 } // namespace react

package/common/cpp/react/renderer/components/rnscreens/RNSScreenState.cpp

@@ -3,11 +3,32 @@
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 #ifdef ANDROID
 folly::dynamic RNSScreenState::getDynamic() const {
   return folly::dynamic::object("frameWidth", frameSize.width)(
-      "frameHeight", frameSize.height)("contentOffsetX", contentOffset.x)("contentOffsetY", contentOffset.y);
+      "frameHeight", frameSize.height)("contentOffsetX", contentOffset.x)(
+      "contentOffsetY", contentOffset.y);
+}
+
+void RNSScreenState::setHeaderHeight(float headerHeight) {
+  lastKnownHeaderHeight_ = headerHeight;
+}
+
+float RNSScreenState::getLastKnownHeaderHeight() const noexcept {
+  return lastKnownHeaderHeight_;
 }
+
+FrameCorrectionModes &RNSScreenState::getFrameCorrectionModes() noexcept {
+  return headerCorrectionModes_;
+}
+
+const FrameCorrectionModes &RNSScreenState::getHeaderCorrectionModes()
+    const noexcept {
+  return headerCorrectionModes_;
+}
+
 #endif
 
 } // namespace react

package/common/cpp/react/renderer/components/rnscreens/RNSScreenState.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <react/renderer/graphics/Float.h>
 #include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/graphics/Float.h>
 
 #ifdef ANDROID
 #include <folly/dynamic.h>
@@ -9,31 +9,35 @@
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
 #endif
 
+#include "FrameCorrectionModes.h"
+
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 class JSI_EXPORT RNSScreenState final {
  public:
   using Shared = std::shared_ptr<const RNSScreenState>;
 
   RNSScreenState(){};
-  RNSScreenState(Size frameSize_, Point contentOffset_) : frameSize(frameSize_), contentOffset(contentOffset_){};
+  RNSScreenState(Size frameSize_, Point contentOffset_)
+      : frameSize(frameSize_), contentOffset(contentOffset_){};
 
 #ifdef ANDROID
-  RNSScreenState(
-      RNSScreenState const &previousState,
-      folly::dynamic data)
+  RNSScreenState(RNSScreenState const &previousState, folly::dynamic data)
       : frameSize(Size{
             (Float)data["frameWidth"].getDouble(),
-          (Float)data["frameHeight"].getDouble()}),
+            (Float)data["frameHeight"].getDouble()}),
         contentOffset(Point{
             (Float)data["contentOffsetX"].getDouble(),
-          (Float)data["contentOffsetY"].getDouble()})
-    {};
+            (Float)data["contentOffsetY"].getDouble()}),
+        lastKnownHeaderHeight_{previousState.lastKnownHeaderHeight_},
+        headerCorrectionModes_{previousState.headerCorrectionModes_} {};
 #endif
 
-    const Size frameSize{};
-    Point contentOffset;
+  const Size frameSize{};
+  Point contentOffset;
 
 #ifdef ANDROID
   folly::dynamic getDynamic() const;
@@ -41,8 +45,24 @@ class JSI_EXPORT RNSScreenState final {
     return MapBufferBuilder::EMPTY();
   };
 
+  void setHeaderHeight(float headerHeight);
+
+  float getLastKnownHeaderHeight() const noexcept;
+
+  FrameCorrectionModes &getFrameCorrectionModes() noexcept;
+
+  const FrameCorrectionModes &getHeaderCorrectionModes() const noexcept;
+
 #endif
 
+ private:
+#ifdef ANDROID
+  // Header height as measured on dummy layout
+  float lastKnownHeaderHeight_{0.f};
+
+  FrameCorrectionModes headerCorrectionModes_{};
+#endif // ANDROID
+
 #pragma mark - Getters
 };
 

package/common/cpp/react/renderer/components/rnscreens/utils/RectUtil.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/graphics/Size.h>
+#include <cmath>
+#include <concepts>
+
+namespace rnscreens {
+
+namespace react = facebook::react;
+
+template <typename T>
+  requires std::is_floating_point_v<T>
+inline constexpr bool equalWithRespectToEps(const T a, const T b, const T eps) {
+  return std::abs(a - b) <= eps;
+}
+
+/**
+ * Compares given two frame sizes with respect to the epsilon.
+ *
+ * @param first first frame size
+ * @param second second frame size
+ * @param eps comparison precision, defaults to 0.01, which should ensure that
+ * precision of comparison is under 1px
+ * @return whether the frame dimensions are the same with respect to given
+ * epsilon
+ */
+inline constexpr bool checkFrameSizesEqualWithEps(
+    const react::Size &first,
+    const react::Size &second,
+    const react::Float eps = 0.01) {
+  return equalWithRespectToEps(first.width, second.width, eps) &&
+      equalWithRespectToEps(first.height, second.height, eps);
+}
+
+} // namespace rnscreens

package/cpp/RNSScreenRemovalListener.cpp

@@ -0,0 +1,25 @@
+#include "RNSScreenRemovalListener.h"
+#include <react/renderer/mounting/ShadowViewMutation.h>
+using namespace facebook::react;
+
+std::optional<MountingTransaction> RNSScreenRemovalListener::pullTransaction(
+    SurfaceId surfaceId,
+    MountingTransaction::Number transactionNumber,
+    const TransactionTelemetry &telemetry,
+    ShadowViewMutationList mutations) const {
+  for (const ShadowViewMutation &mutation : mutations) {
+    if (mutation.type == ShadowViewMutation::Type::Remove &&
+        mutation.oldChildShadowView.componentName != nullptr &&
+        strcmp(mutation.parentShadowView.componentName, "RNSScreenStack") ==
+            0) {
+      listenerFunction_(mutation.oldChildShadowView.tag);
+    }
+  }
+
+  return MountingTransaction{
+      surfaceId, transactionNumber, std::move(mutations), telemetry};
+}
+
+bool RNSScreenRemovalListener::shouldOverridePullTransaction() const {
+  return true;
+}

package/cpp/RNSScreenRemovalListener.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+using namespace facebook::react;
+
+struct RNSScreenRemovalListener : public MountingOverrideDelegate {
+  std::function<void(int)> listenerFunction_;
+  RNSScreenRemovalListener(std::function<void(int)> &&listenerFunction_)
+      : listenerFunction_(std::move(listenerFunction_)) {}
+
+  bool shouldOverridePullTransaction() const override;
+  std::optional<MountingTransaction> pullTransaction(
+      SurfaceId surfaceId,
+      MountingTransaction::Number number,
+      const TransactionTelemetry &telemetry,
+      ShadowViewMutationList mutations) const override;
+};