react-native-screens 3.32.0 → 3.33.0

package/android/src/main/java/com/swmansion/rnscreens/events/SearchBarCloseEvent.kt

@@ -4,7 +4,10 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 
-class SearchBarCloseEvent(surfaceId: Int, viewId: Int) : Event<SearchBarCloseEvent>(surfaceId, viewId) {
+class SearchBarCloseEvent(
+    surfaceId: Int,
+    viewId: Int,
+) : Event<SearchBarCloseEvent>(surfaceId, viewId) {
     override fun getEventName(): String = EVENT_NAME
 
     // All events for a given view can be coalesced.

package/android/src/main/java/com/swmansion/rnscreens/events/SearchBarFocusEvent.kt

@@ -4,7 +4,10 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 
-class SearchBarFocusEvent(surfaceId: Int, viewId: Int) : Event<SearchBarFocusEvent>(surfaceId, viewId) {
+class SearchBarFocusEvent(
+    surfaceId: Int,
+    viewId: Int,
+) : Event<SearchBarFocusEvent>(surfaceId, viewId) {
     override fun getEventName(): String = EVENT_NAME
 
     // All events for a given view can be coalesced.

package/android/src/main/java/com/swmansion/rnscreens/events/SearchBarOpenEvent.kt

@@ -4,7 +4,10 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 
-class SearchBarOpenEvent(surfaceId: Int, viewId: Int) : Event<SearchBarOpenEvent>(surfaceId, viewId) {
+class SearchBarOpenEvent(
+    surfaceId: Int,
+    viewId: Int,
+) : Event<SearchBarOpenEvent>(surfaceId, viewId) {
     override fun getEventName(): String = EVENT_NAME
 
     // All events for a given view can be coalesced.

package/android/src/main/java/com/swmansion/rnscreens/events/SearchBarSearchButtonPressEvent.kt

@@ -4,15 +4,20 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 
-class SearchBarSearchButtonPressEvent(surfaceId: Int, viewId: Int, private val text: String?) : Event<SearchBarSearchButtonPressEvent>(surfaceId, viewId) {
+class SearchBarSearchButtonPressEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val text: String?,
+) : Event<SearchBarSearchButtonPressEvent>(surfaceId, viewId) {
     override fun getEventName(): String = EVENT_NAME
 
     // All events for a given view can be coalesced.
     override fun getCoalescingKey(): Short = 0
 
-    override fun getEventData(): WritableMap? = Arguments.createMap().apply {
-        putString("text", text)
-    }
+    override fun getEventData(): WritableMap? =
+        Arguments.createMap().apply {
+            putString("text", text)
+        }
 
     companion object {
         const val EVENT_NAME = "topSearchButtonPress"

package/android/src/main/java/com/swmansion/rnscreens/events/StackFinishTransitioningEvent.kt

@@ -4,7 +4,10 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 
-class StackFinishTransitioningEvent(surfaceId: Int, viewId: Int) : Event<StackFinishTransitioningEvent>(surfaceId, viewId) {
+class StackFinishTransitioningEvent(
+    surfaceId: Int,
+    viewId: Int,
+) : Event<StackFinishTransitioningEvent>(surfaceId, viewId) {
     override fun getEventName() = EVENT_NAME
 
     // All events for a given view can be coalesced.

package/android/src/main/java/com/swmansion/rnscreens/utils/DeviceUtils.kt

@@ -4,9 +4,5 @@ import android.content.Context
 import android.content.pm.PackageManager
 
 object DeviceUtils {
-
-    fun isPlatformAndroidTV(context: Context?): Boolean {
-        return context?.packageManager?.hasSystemFeature(PackageManager.FEATURE_LEANBACK) == true
-    }
-
+    fun isPlatformAndroidTV(context: Context?): Boolean = context?.packageManager?.hasSystemFeature(PackageManager.FEATURE_LEANBACK) == true
 }

package/android/src/main/java/com/swmansion/rnscreens/utils/ScreenDummyLayoutHelper.kt

@@ -0,0 +1,214 @@
+package com.swmansion.rnscreens.utils
+
+import android.app.Activity
+import android.util.Log
+import android.view.View
+import androidx.appcompat.widget.Toolbar
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.PixelUtil
+import com.google.android.material.appbar.AppBarLayout
+import com.swmansion.rnscreens.ScreenStackHeaderConfig
+import java.lang.ref.WeakReference
+
+/**
+ * This class provides methods to create dummy layout (that mimics Screen setup), and to compute
+ * expected header height. It is meant to be accessed from C++ layer via JNI.
+ * See https://github.com/software-mansion/react-native-screens/pull/2169
+ * for more detailed description of the issue this code solves.
+ */
+internal class ScreenDummyLayoutHelper(
+    reactContext: ReactApplicationContext,
+) {
+    // The state required to compute header dimensions. We want this on instance rather than on class
+    // for context access & being tied to instance lifetime.
+    private lateinit var coordinatorLayout: CoordinatorLayout
+    private lateinit var appBarLayout: AppBarLayout
+    private lateinit var dummyContentView: View
+    private lateinit var toolbar: Toolbar
+    private var defaultFontSize: Float = 0f
+    private var defaultContentInsetStartWithNavigation: Int = 0
+
+    // LRU with size 1
+    private var cache: CacheEntry = CacheEntry.EMPTY
+
+    // We do not want to be responsible for the context lifecycle. If it's null, we're fine.
+    // This same context is being passed down to our view components so it is destroyed
+    // only if our views also are.
+    private var reactContextRef: WeakReference<ReactApplicationContext> =
+        WeakReference(reactContext)
+
+    init {
+
+        // We load the library so that we are able to communicate with our C++ code (descriptor & shadow nodes).
+        // Basically we leak this object to C++, as its lifecycle should span throughout whole application
+        // lifecycle anyway.
+        try {
+            System.loadLibrary(LIBRARY_NAME)
+        } catch (e: UnsatisfiedLinkError) {
+            Log.w(TAG, "Failed to load $LIBRARY_NAME")
+        }
+
+        weakInstance = WeakReference(this)
+        ensureDummyLayoutWithHeader(reactContext)
+    }
+
+    /**
+     * Initializes dummy view hierarchy with CoordinatorLayout, AppBarLayout and dummy View.
+     * We utilize this to compute header height (app bar layout height) from C++ layer when its needed.
+     */
+    private fun ensureDummyLayoutWithHeader(reactContext: ReactApplicationContext) {
+        if (::coordinatorLayout.isInitialized) {
+            return
+        }
+
+        // We need to use activity here, as react context does not have theme attributes required by
+        // AppBarLayout attached leading to crash.
+        val contextWithTheme =
+            requireNotNull(reactContext.currentActivity) { "[RNScreens] Attempt to use context detached from activity" }
+
+        coordinatorLayout = CoordinatorLayout(contextWithTheme)
+
+        appBarLayout =
+            AppBarLayout(contextWithTheme).apply {
+                layoutParams =
+                    CoordinatorLayout.LayoutParams(
+                        CoordinatorLayout.LayoutParams.MATCH_PARENT,
+                        CoordinatorLayout.LayoutParams.WRAP_CONTENT,
+                    )
+            }
+
+        toolbar =
+            Toolbar(contextWithTheme).apply {
+                title = DEFAULT_HEADER_TITLE
+                layoutParams =
+                    AppBarLayout
+                        .LayoutParams(
+                            AppBarLayout.LayoutParams.MATCH_PARENT,
+                            AppBarLayout.LayoutParams.WRAP_CONTENT,
+                        ).apply { scrollFlags = 0 }
+            }
+
+        // We know the title text view will be there, cause we've just set title.
+        defaultFontSize = ScreenStackHeaderConfig.findTitleTextViewInToolbar(toolbar)!!.textSize
+        defaultContentInsetStartWithNavigation = toolbar.contentInsetStartWithNavigation
+
+        appBarLayout.addView(toolbar)
+
+        dummyContentView =
+            View(contextWithTheme).apply {
+                layoutParams =
+                    CoordinatorLayout.LayoutParams(
+                        CoordinatorLayout.LayoutParams.MATCH_PARENT,
+                        CoordinatorLayout.LayoutParams.MATCH_PARENT,
+                    )
+            }
+
+        coordinatorLayout.apply {
+            addView(appBarLayout)
+            addView(dummyContentView)
+        }
+    }
+
+    /**
+     * Triggers layout pass on dummy view hierarchy, taking into consideration selected
+     * ScreenStackHeaderConfig props that might have impact on final header height.
+     *
+     * @param fontSize font size value as passed from JS
+     * @return header height in dp as consumed by Yoga
+     */
+    private fun computeDummyLayout(
+        fontSize: Int,
+        isTitleEmpty: Boolean,
+    ): Float {
+        if (!::coordinatorLayout.isInitialized) {
+            Log.e(
+                TAG,
+                "[RNScreens] Attempt to access dummy view hierarchy before it is initialized",
+            )
+            return 0.0f
+        }
+
+        if (cache.hasKey(CacheKey(fontSize, isTitleEmpty))) {
+            return cache.headerHeight
+        }
+
+        val topLevelDecorView = requireActivity().window.decorView
+
+        // These dimensions are not accurate, as they do include status bar & navigation bar, however
+        // it is ok for our purposes.
+        val decorViewWidth = topLevelDecorView.width
+        val decorViewHeight = topLevelDecorView.height
+
+        val widthMeasureSpec =
+            View.MeasureSpec.makeMeasureSpec(decorViewWidth, View.MeasureSpec.EXACTLY)
+        val heightMeasureSpec =
+            View.MeasureSpec.makeMeasureSpec(decorViewHeight, View.MeasureSpec.EXACTLY)
+
+        if (isTitleEmpty) {
+            toolbar.title = ""
+            toolbar.contentInsetStartWithNavigation = 0
+        } else {
+            toolbar.title = DEFAULT_HEADER_TITLE
+            toolbar.contentInsetStartWithNavigation = defaultContentInsetStartWithNavigation
+        }
+
+        val textView = ScreenStackHeaderConfig.findTitleTextViewInToolbar(toolbar)
+        textView?.textSize =
+            if (fontSize != FONT_SIZE_UNSET) fontSize.toFloat() else defaultFontSize
+
+        coordinatorLayout.measure(widthMeasureSpec, heightMeasureSpec)
+
+        // It seems that measure pass would be enough, however I'm not certain whether there are no
+        // scenarios when layout violates measured dimensions.
+        coordinatorLayout.layout(0, 0, decorViewWidth, decorViewHeight)
+
+        val headerHeight = PixelUtil.toDIPFromPixel(appBarLayout.height.toFloat())
+        cache = CacheEntry(CacheKey(fontSize, isTitleEmpty), headerHeight)
+        return headerHeight
+    }
+
+    private fun requireReactContext(): ReactApplicationContext =
+        requireNotNull(reactContextRef.get()) {
+            "[RNScreens] Attempt to require missing react context"
+        }
+
+    private fun requireActivity(): Activity =
+        requireNotNull(requireReactContext().currentActivity) {
+            "[RNScreens] Attempt to use context detached from activity"
+        }
+
+    companion object {
+        const val TAG = "ScreenDummyLayoutHelper"
+
+        const val LIBRARY_NAME = "react_codegen_rnscreens"
+
+        const val FONT_SIZE_UNSET = -1
+
+        private const val DEFAULT_HEADER_TITLE: String = "FontSize123!#$"
+
+        // We access this field from C++ layer, through `getInstance` method.
+        // We don't care what instance we get access to as long as it has initialized
+        // dummy view hierarchy.
+        private var weakInstance = WeakReference<ScreenDummyLayoutHelper>(null)
+
+        @JvmStatic
+        fun getInstance(): ScreenDummyLayoutHelper? = weakInstance.get()
+    }
+}
+
+private data class CacheKey(
+    val fontSize: Int,
+    val isTitleEmpty: Boolean,
+)
+
+private class CacheEntry(
+    val cacheKey: CacheKey,
+    val headerHeight: Float,
+) {
+    fun hasKey(key: CacheKey) = cacheKey.fontSize != Int.MIN_VALUE && cacheKey == key
+
+    companion object {
+        val EMPTY = CacheEntry(CacheKey(Int.MIN_VALUE, false), 0f)
+    }
+}

package/android/src/main/jni/CMakeLists.txt

@@ -6,6 +6,7 @@ set(LIB_TARGET_NAME react_codegen_${LIB_LITERAL})
 
 set(LIB_ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
 set(LIB_COMMON_DIR ${LIB_ANDROID_DIR}/../common/cpp)
+set(LIB_COMMON_COMPONENTS_DIR ${LIB_COMMON_DIR}/react/renderer/components/${LIB_LITERAL})
 set(LIB_ANDROID_GENERATED_JNI_DIR ${LIB_ANDROID_DIR}/build/generated/source/codegen/jni)
 set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
 
@@ -18,20 +19,20 @@ add_compile_options(
   -Wno-gnu-zero-variadic-macro-arguments
 )
 
-file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS *.cpp ${LIB_COMMON_DIR}/react/renderer/components/${LIB_LITERAL}/*.cpp)
+file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS *.cpp ${LIB_COMMON_COMPONENTS_DIR}/*.cpp ${LIB_COMMON_COMPONENTS_DIR}/utils/*.cpp)
 file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
 
 add_library(
   ${LIB_TARGET_NAME}
-  SHARED 
+  SHARED
   ${LIB_CUSTOM_SRCS}
   ${LIB_CODEGEN_SRCS}
 )
 
 target_include_directories(
   ${LIB_TARGET_NAME}
-  PUBLIC 
-  . 
+  PUBLIC
+  .
   ${LIB_COMMON_DIR}
   ${LIB_ANDROID_GENERATED_JNI_DIR}
   ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}

package/android/src/paper/java/com/facebook/react/viewmanagers/RNSScreenManagerDelegate.java

@@ -44,6 +44,9 @@ public class RNSScreenManagerDelegate<T extends View, U extends BaseViewManagerI
       case "fullScreenSwipeEnabled":
         mViewManager.setFullScreenSwipeEnabled(view, value == null ? false : (boolean) value);
         break;
+      case "fullScreenSwipeShadowEnabled":
+        mViewManager.setFullScreenSwipeShadowEnabled(view, value == null ? false : (boolean) value);
+        break;
       case "homeIndicatorHidden":
         mViewManager.setHomeIndicatorHidden(view, value == null ? false : (boolean) value);
         break;

package/android/src/paper/java/com/facebook/react/viewmanagers/RNSScreenManagerInterface.java

@@ -21,6 +21,7 @@ public interface RNSScreenManagerInterface<T extends View> {
   void setSheetExpandsWhenScrolledToEdge(T view, boolean value);
   void setCustomAnimationOnSwipe(T view, boolean value);
   void setFullScreenSwipeEnabled(T view, boolean value);
+  void setFullScreenSwipeShadowEnabled(T view, boolean value);
   void setHomeIndicatorHidden(T view, boolean value);
   void setPreventNativeDismiss(T view, boolean value);
   void setGestureEnabled(T view, boolean value);

package/android/src/paper/java/com/swmansion/rnscreens/FabricEnabledViewGroup.kt

@@ -2,13 +2,18 @@ package com.swmansion.rnscreens
 
 import android.view.ViewGroup
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.uimanager.FabricViewStateManager
+import com.facebook.react.uimanager.StateWrapper
 
-abstract class FabricEnabledViewGroup constructor(context: ReactContext?) : ViewGroup(context) {
+abstract class FabricEnabledViewGroup(
+    context: ReactContext?,
+) : ViewGroup(context) {
+    fun setStateWrapper(wrapper: StateWrapper?) = Unit
 
-    val fabricViewStateManager get() = null as FabricViewStateManager?
-
-    protected fun updateScreenSizeFabric(width: Int, height: Int, headerHeight: Double) {
+    protected fun updateScreenSizeFabric(
+        width: Int,
+        height: Int,
+        headerHeight: Double,
+    ) {
         // do nothing
     }
 }

package/android/src/paper/java/com/swmansion/rnscreens/NativeProxy.kt

@@ -0,0 +1,19 @@
+package com.swmansion.rnscreens
+
+import com.facebook.react.fabric.FabricUIManager
+
+class NativeProxy {
+    // do nothing on Paper
+    fun nativeAddMutationsListener(fabricUIManager: FabricUIManager) = Unit
+
+    companion object {
+        fun addScreenToMap(
+            tag: Int,
+            view: Screen,
+        ) = Unit
+
+        fun removeScreenFromMap(tag: Int) = Unit
+
+        fun clearMapOnInvalidate() = Unit
+    }
+}

package/android/src/paper/java/com/swmansion/rnscreens/NativeScreensModuleSpec.java

@@ -12,8 +12,10 @@
 
 package com.swmansion.rnscreens;
 
+import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReactModuleWithSpec;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import javax.annotation.Nonnull;
@@ -29,4 +31,6 @@ public abstract class NativeScreensModuleSpec extends ReactContextBaseJavaModule
   public @Nonnull String getName() {
     return NAME;
   }
+
+
 }

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

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <cstdint>
+
+namespace rnscreens {
+
+/**
+ * Flags describing types of corrections to apply to Screen frame
+ * after layout process.
+ */
+class FrameCorrectionModes final {
+ public:
+  enum Mode : std::uint8_t {
+    /**
+     * No correction should be applied to layout metrics of Screen
+     */
+    None = 0,
+
+    /**
+     * Screen's frame height should be corrected
+     */
+    FrameHeightCorrection = 1 << 0,
+
+    /**
+     * Screen's frame origin should be corrected
+     */
+    FrameOriginCorrection = 1 << 1,
+  };
+
+  inline void set(Mode mode) {
+    modes_ = Mode(modes_ | mode);
+  }
+
+  inline void unset(Mode mode) {
+    modes_ = Mode(modes_ & ~mode);
+  }
+
+  // Check whether current set of flags contains all flags set in argument.
+  inline bool check(Mode mode) const {
+    return Mode(modes_ & mode) == mode;
+  }
+
+  inline Mode getAll() const {
+    return modes_;
+  }
+
+ private:
+  Mode modes_{Mode::None};
+};
+
+} // namespace rnscreens

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

@@ -20,7 +20,7 @@ class JSI_EXPORT RNSModalScreenShadowNode final
  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,17 +1,27 @@
 #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/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;
 
+  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);
@@ -26,13 +36,142 @@ class RNSScreenComponentDescriptor final
             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