@amazon-devices/react-native-screens 2.0.1759135970 → 3.0.9000000000

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

@@ -3,7 +3,164 @@
 namespace facebook {
 namespace react {
 
+namespace yoga = facebook::yoga;
+using namespace rnscreens;
+
 extern const char RNSScreenComponentName[] = "RNSScreen";
 
+Point RNSScreenShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
+  auto stateData = getStateData();
+  auto contentOffset = stateData.contentOffset;
+  return {contentOffset.x, contentOffset.y};
+}
+
+std::optional<std::reference_wrapper<const ShadowNode::Shared>>
+findHeaderConfigChild(const YogaLayoutableShadowNode &screenShadowNode) {
+  for (const ShadowNode::Shared &child : screenShadowNode.getChildren()) {
+    if (std::strcmp(child->getComponentName(), "RNSScreenStackHeaderConfig") ==
+        0) {
+      return {std::cref(child)};
+    }
+  }
+  return {};
+}
+
+#ifdef ANDROID
+static constexpr const char *kScreenDummyLayoutHelperClass =
+    "com/swmansion/rnscreens/utils/ScreenDummyLayoutHelper";
+
+std::optional<float> findHeaderHeight(
+    const int fontSize,
+    const bool isTitleEmpty) {
+  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
+
+void RNSScreenShadowNode::appendChild(const ShadowNode::Shared &child) {
+  YogaLayoutableShadowNode::appendChild(child);
+#ifdef ANDROID
+  const auto &stateData = getStateData();
+  if (stateData.frameSize.width == 0 || stateData.frameSize.height == 0) {
+    // 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(*this);
+    auto &screenShadowNode = static_cast<RNSScreenShadowNode &>(*this);
+
+    // 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));
+    }
+  }
+#endif // ANDROID
+}
+
+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,29 +1,49 @@
 #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 appendChild(const ShadowNode::Shared &child) override;
+
+  void layout(LayoutContext layoutContext) override;
+
+#pragma mark - Custom interface
+
+  void setHeaderHeight(float headerHeight);
+
+  FrameCorrectionModes &getFrameCorrectionModes();
+
+ private:
+#ifdef ANDROID
+  void applyFrameCorrections();
 
-  static ShadowNodeTraits BaseTraits() {
-    auto traits = ConcreteViewShadowNode::BaseTraits();
-    traits.set(ShadowNodeTraits::Trait::RootNodeKind);
-    return traits;
-  }
+  StateData &getStateDataMutable();
+#endif // ANDROID
 };
 
 } // namespace react

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

@@ -0,0 +1,49 @@
+#pragma once
+
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#endif
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/components/rnscreens/Props.h>
+#include <react/renderer/components/rnscreens/utils/RectUtil.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSScreenStackHeaderConfigShadowNode.h"
+
+namespace facebook::react {
+
+using namespace rnscreens;
+
+class RNSScreenStackHeaderConfigComponentDescriptor final
+    : public ConcreteComponentDescriptor<RNSScreenStackHeaderConfigShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(
+        dynamic_cast<RNSScreenStackHeaderConfigShadowNode *>(&shadowNode));
+    auto &configShadowNode =
+        static_cast<RNSScreenStackHeaderConfigShadowNode &>(shadowNode);
+
+    react_native_assert(
+        dynamic_cast<YogaLayoutableShadowNode *>(&configShadowNode));
+    auto &layoutableShadowNode =
+        dynamic_cast<YogaLayoutableShadowNode &>(configShadowNode);
+
+    auto state = std::static_pointer_cast<
+        const RNSScreenStackHeaderConfigShadowNode::ConcreteState>(
+        shadowNode.getState());
+    auto stateData = state->getData();
+
+    layoutableShadowNode.setPadding(
+        {stateData.getPaddingStart(), 0, stateData.getPaddingEnd(), 0});
+
+    ConcreteComponentDescriptor::adopt(shadowNode);
+#if !defined(ANDROID) && !defined(NDEBUG)
+    std::weak_ptr<void> imageLoader =
+        contextContainer_->at<std::shared_ptr<void>>("RCTImageLoader");
+    configShadowNode.setImageLoader(imageLoader);
+#endif // !ANDROID && !NDEBUG
+  }
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,22 @@
+#include "RNSScreenStackHeaderConfigShadowNode.h"
+
+namespace facebook::react {
+
+extern const char RNSScreenStackHeaderConfigComponentName[] =
+    "RNSScreenStackHeaderConfig";
+
+#if !defined(ANDROID) && !defined(NDEBUG)
+void RNSScreenStackHeaderConfigShadowNode::setImageLoader(
+    std::weak_ptr<void> imageLoader) {
+  getStateDataMutable().setImageLoader(imageLoader);
+}
+RNSScreenStackHeaderConfigShadowNode::StateData &
+RNSScreenStackHeaderConfigShadowNode::getStateDataMutable() {
+  // We assume that this method is called to mutate the data, so we ensure
+  // we're unsealed.
+  ensureUnsealed();
+  return const_cast<RNSScreenStackHeaderConfigShadowNode::StateData &>(
+      getStateData());
+}
+#endif // !ANDROID && !NDEBUG
+} // namespace facebook::react

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#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 <react/renderer/core/LayoutContext.h>
+#include "FrameCorrectionModes.h"
+#include "RNSScreenStackHeaderConfigState.h"
+
+namespace facebook::react {
+
+using namespace rnscreens;
+
+JSI_EXPORT extern const char RNSScreenStackHeaderConfigComponentName[];
+
+class JSI_EXPORT RNSScreenStackHeaderConfigShadowNode final
+    : public ConcreteViewShadowNode<
+          RNSScreenStackHeaderConfigComponentName,
+          RNSScreenStackHeaderConfigProps,
+          RNSScreenStackHeaderConfigEventEmitter,
+          RNSScreenStackHeaderConfigState> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  using StateData = ConcreteViewShadowNode::ConcreteStateData;
+
+#pragma mark - ShadowNode overrides
+
+#pragma mark - Custom interface
+#if !defined(ANDROID) && !defined(NDEBUG)
+  void setImageLoader(std::weak_ptr<void> imageLoader);
+#endif // !ANDROID && !NDEBUG
+
+ private:
+#if !defined(ANDROID) && !defined(NDEBUG)
+  StateData &getStateDataMutable();
+#endif // !ANDROID && !NDEBUG
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,34 @@
+#include "RNSScreenStackHeaderConfigState.h"
+
+namespace facebook {
+namespace react {
+
+#ifdef ANDROID
+folly::dynamic RNSScreenStackHeaderConfigState::getDynamic() const {
+  return folly::dynamic::object("paddingStart", paddingStart_)(
+      "paddingEnd_", paddingEnd_);
+}
+#else // ANDROID
+#ifndef NDEBUG
+void RNSScreenStackHeaderConfigState::setImageLoader(
+    std::weak_ptr<void> imageLoader) {
+  imageLoader_ = imageLoader;
+}
+
+std::weak_ptr<void> RNSScreenStackHeaderConfigState::getImageLoader()
+    const noexcept {
+  return imageLoader_;
+}
+#endif // !NDEBUG
+#endif // ANDROID
+
+Float RNSScreenStackHeaderConfigState::getPaddingStart() const noexcept {
+  return paddingStart_;
+}
+
+Float RNSScreenStackHeaderConfigState::getPaddingEnd() const noexcept {
+  return paddingEnd_;
+}
+
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/graphics/Float.h>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook::react {
+
+class JSI_EXPORT RNSScreenStackHeaderConfigState final {
+ public:
+  using Shared = std::shared_ptr<const RNSScreenStackHeaderConfigState>;
+
+  RNSScreenStackHeaderConfigState() = default;
+
+  RNSScreenStackHeaderConfigState(Float paddingStart, Float paddingEnd)
+      : paddingStart_{paddingStart}, paddingEnd_{paddingEnd} {}
+
+#ifdef ANDROID
+  RNSScreenStackHeaderConfigState(
+      RNSScreenStackHeaderConfigState const &previousState,
+      folly::dynamic data)
+      : paddingStart_{static_cast<Float>(data["paddingStart"].getDouble())},
+        paddingEnd_{static_cast<Float>(data["paddingEnd"].getDouble())} {}
+#endif
+
+#ifdef ANDROID
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  };
+#else // ANDROID
+#ifndef NDEBUG
+  void setImageLoader(std::weak_ptr<void> imageLoader);
+  std::weak_ptr<void> getImageLoader() const noexcept;
+#endif // !NDEBUG
+#endif // ANDROID
+
+#pragma mark - Getters
+
+  [[nodiscard]] Float getPaddingStart() const noexcept;
+
+  [[nodiscard]] Float getPaddingEnd() const noexcept;
+
+ private:
+  Float paddingStart_{0.f};
+  Float paddingEnd_{0.f};
+#if !defined(ANDROID) && !defined(NDEBUG)
+  std::weak_ptr<void> imageLoader_;
+#endif // !ANDROID && !NDEBUG
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#endif // ANDROID
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/components/rnscreens/Props.h>
+#include <react/renderer/components/rnscreens/utils/RectUtil.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSScreenStackHeaderSubviewShadowNode.h"
+
+namespace facebook::react {
+
+using namespace rnscreens;
+
+class RNSScreenStackHeaderSubviewComponentDescriptor final
+    : public ConcreteComponentDescriptor<
+          RNSScreenStackHeaderSubviewShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,8 @@
+#include "RNSScreenStackHeaderSubviewShadowNode.h"
+
+namespace facebook::react {
+
+extern const char RNSScreenStackHeaderSubviewComponentName[] =
+    "RNSScreenStackHeaderSubview";
+
+} // namespace facebook::react

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#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 <react/renderer/core/LayoutContext.h>
+#include "FrameCorrectionModes.h"
+#include "RNSScreenStackHeaderSubviewState.h"
+
+namespace facebook::react {
+
+using namespace rnscreens;
+
+JSI_EXPORT extern const char RNSScreenStackHeaderSubviewComponentName[];
+
+class JSI_EXPORT RNSScreenStackHeaderSubviewShadowNode final
+    : public ConcreteViewShadowNode<
+          RNSScreenStackHeaderSubviewComponentName,
+          RNSScreenStackHeaderSubviewProps,
+          RNSScreenStackHeaderSubviewEventEmitter,
+          RNSScreenStackHeaderSubviewState> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  using StateData = ConcreteViewShadowNode::ConcreteStateData;
+#pragma mark - ShadowNode overrides
+
+#pragma mark - Custom interface
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,15 @@
+#include "RNSScreenStackHeaderSubviewState.h"
+
+namespace facebook {
+namespace react {
+
+using namespace rnscreens;
+
+#ifdef ANDROID
+folly::dynamic RNSScreenStackHeaderSubviewState::getDynamic() const {
+  return folly::dynamic::object();
+}
+#endif // ANDROID
+
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/graphics/Float.h>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+#include "FrameCorrectionModes.h"
+
+namespace facebook::react {
+
+using namespace rnscreens;
+
+class JSI_EXPORT RNSScreenStackHeaderSubviewState final {
+ public:
+  using Shared = std::shared_ptr<const RNSScreenStackHeaderSubviewState>;
+
+  RNSScreenStackHeaderSubviewState() = default;
+
+#ifdef ANDROID
+  RNSScreenStackHeaderSubviewState(
+      RNSScreenStackHeaderSubviewState const &previousState,
+      folly::dynamic data) {}
+#endif
+
+#ifdef ANDROID
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  };
+#endif // ANDROID
+#pragma mark - Getters
+};
+
+} // namespace facebook::react

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

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

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

@@ -1,34 +1,43 @@
 #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>
 #include <react/renderer/mapbuffer/MapBuffer.h>
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
-#endif
+#endif // ANDROID
+
+#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_) : frameSize(frameSize_){};
+  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()}),
+        lastKnownHeaderHeight_{previousState.lastKnownHeaderHeight_},
+        headerCorrectionModes_{previousState.headerCorrectionModes_} {};
 #endif
 
   const Size frameSize{};
+  Point contentOffset;
 
 #ifdef ANDROID
   folly::dynamic getDynamic() const;
@@ -36,7 +45,23 @@ class JSI_EXPORT RNSScreenState final {
     return MapBufferBuilder::EMPTY();
   };
 
-#endif
+  void setHeaderHeight(float headerHeight);
+
+  float getLastKnownHeaderHeight() const noexcept;
+
+  FrameCorrectionModes &getFrameCorrectionModes() noexcept;
+
+  const FrameCorrectionModes &getHeaderCorrectionModes() const noexcept;
+
+#endif // ANDROID
+
+ private:
+#ifdef ANDROID
+  // Header height as measured on dummy layout
+  float lastKnownHeaderHeight_{0.f};
+
+  FrameCorrectionModes headerCorrectionModes_{};
+#endif // ANDROID
 
 #pragma mark - Getters
 };