react-native-screens 4.24.0 → 4.25.0-beta.2

package/android/src/main/java/com/swmansion/rnscreens/safearea/SafeAreaViewManager.kt

@@ -10,11 +10,8 @@ import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.ViewManagerDelegate
-import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.viewmanagers.RNSSafeAreaViewManagerDelegate
 import com.facebook.react.viewmanagers.RNSSafeAreaViewManagerInterface
-import com.swmansion.rnscreens.safearea.paper.SafeAreaViewEdges
-import com.swmansion.rnscreens.safearea.paper.SafeAreaViewShadowNode
 
 @ReactModule(name = SafeAreaViewManager.REACT_CLASS)
 class SafeAreaViewManager :
@@ -28,11 +25,6 @@ class SafeAreaViewManager :
 
     override fun getDelegate() = delegate
 
-    override fun createShadowNodeInstance() = SafeAreaViewShadowNode()
-
-    override fun getShadowNodeClass() = SafeAreaViewShadowNode::class.java
-
-    @ReactProp(name = "edges")
     override fun setEdges(
         view: SafeAreaView,
         value: ReadableMap?,
@@ -42,7 +34,6 @@ class SafeAreaViewManager :
         }
     }
 
-    @ReactProp(name = "insetType")
     override fun setInsetType(
         view: SafeAreaView,
         value: String?,

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

@@ -0,0 +1,25 @@
+package com.swmansion.rnscreens.utils
+
+import android.content.Context
+import android.graphics.Color
+import android.util.Log
+import android.util.TypedValue
+import androidx.annotation.ColorInt
+
+private const val TAG = "ColorUtils"
+
+internal fun resolveColorAttr(
+    context: Context,
+    attr: Int,
+    @ColorInt defaultColor: Int = Color.TRANSPARENT,
+): Int {
+    val typedValue = TypedValue()
+    val resolved = context.theme.resolveAttribute(attr, typedValue, true)
+
+    if (!resolved) {
+        Log.w(TAG, "[RNScreens] Failed to resolve color attribute. Falling back to $defaultColor.")
+        return defaultColor
+    }
+
+    return typedValue.data
+}

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

@@ -0,0 +1,18 @@
+package com.swmansion.rnscreens.utils
+
+import android.content.Context
+import android.util.TypedValue
+
+internal fun resolveDimensionAttr(
+    context: Context,
+    attrId: Int,
+): Int {
+    val typedValue = TypedValue()
+    require(context.theme.resolveAttribute(attrId, typedValue, true)) {
+        "[RNScreens] Unable to resolve Material theme dimension."
+    }
+    return TypedValue.complexToDimensionPixelSize(
+        typedValue.data,
+        context.resources.displayMetrics,
+    )
+}

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

@@ -0,0 +1,23 @@
+package com.swmansion.rnscreens.utils
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.util.Log
+import android.util.TypedValue
+import androidx.appcompat.content.res.AppCompatResources
+
+private const val TAG = "DrawableUtils"
+
+internal fun resolveDrawableAttr(
+    context: Context,
+    attrId: Int,
+): Drawable? {
+    val typedValue = TypedValue()
+    if (!context.theme.resolveAttribute(attrId, typedValue, true) ||
+        typedValue.resourceId == 0
+    ) {
+        Log.w(TAG, "[RNScreens] Failed to resolve drawable attribute.")
+        return null
+    }
+    return AppCompatResources.getDrawable(context, typedValue.resourceId)
+}

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

@@ -4,22 +4,90 @@ import android.util.Log
 import com.swmansion.rnscreens.BuildConfig
 
 object RNSLog {
-    fun d(
+    private inline fun logIfEnabled(
         tag: String,
-        message: String,
+        msg: String,
+        logger: (String, String) -> Int,
     ) {
         if (BuildConfig.RNS_DEBUG_LOGGING) {
-            Log.d(tag, message)
+            logger(tag, msg)
         }
     }
 
-    fun d(
+    private inline fun logIfEnabled(
         tag: String,
-        message: String,
-        vararg args: Any,
+        msg: String,
+        tr: Throwable,
+        logger: (String, String, Throwable) -> Int,
     ) {
         if (BuildConfig.RNS_DEBUG_LOGGING) {
-            Log.d(tag, message.format(*args))
+            logger(tag, msg, tr)
         }
     }
+
+    fun d(
+        tag: String,
+        msg: String,
+    ) = logIfEnabled(tag, msg, Log::d)
+
+    fun d(
+        tag: String,
+        msg: String,
+        tr: Throwable,
+    ) = logIfEnabled(tag, msg, tr, Log::d)
+
+    fun e(
+        tag: String,
+        msg: String,
+    ) = logIfEnabled(tag, msg, Log::e)
+
+    fun e(
+        tag: String,
+        msg: String,
+        tr: Throwable,
+    ) = logIfEnabled(tag, msg, tr, Log::e)
+
+    fun i(
+        tag: String,
+        msg: String,
+    ) = logIfEnabled(tag, msg, Log::i)
+
+    fun i(
+        tag: String,
+        msg: String,
+        tr: Throwable,
+    ) = logIfEnabled(tag, msg, tr, Log::i)
+
+    fun v(
+        tag: String,
+        msg: String,
+    ) = logIfEnabled(tag, msg, Log::v)
+
+    fun v(
+        tag: String,
+        msg: String,
+        tr: Throwable,
+    ) = logIfEnabled(tag, msg, tr, Log::v)
+
+    fun w(
+        tag: String,
+        msg: String,
+    ) = logIfEnabled(tag, msg, Log::w)
+
+    fun w(
+        tag: String,
+        msg: String,
+        tr: Throwable,
+    ) = logIfEnabled(tag, msg, tr, Log::w)
+
+    fun wtf(
+        tag: String,
+        msg: String,
+    ) = logIfEnabled(tag, msg, Log::wtf)
+
+    fun wtf(
+        tag: String,
+        msg: String,
+        tr: Throwable,
+    ) = logIfEnabled(tag, msg, tr, Log::wtf)
 }

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

@@ -1,7 +1,9 @@
 package com.swmansion.rnscreens.utils
 
 import android.app.Activity
+import android.app.Application
 import android.content.Context
+import android.os.Bundle
 import android.util.Log
 import android.view.View
 import androidx.appcompat.widget.Toolbar
@@ -26,10 +28,10 @@ internal class ScreenDummyLayoutHelper(
 ) : LifecycleEventListener {
     // 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 coordinatorLayout: CoordinatorLayout? = null
+    private var appBarLayout: AppBarLayout? = null
+    private var dummyContentView: View? = null
+    private var toolbar: Toolbar? = null
     private var defaultFontSize: Float = 0f
     private var defaultContentInsetStartWithNavigation: Int = 0
 
@@ -42,6 +44,9 @@ internal class ScreenDummyLayoutHelper(
     private var reactContextRef: WeakReference<ReactApplicationContext> =
         WeakReference(reactContext)
 
+    // We're relying on the native notification for performing cleanup, rather than relying on ReactNative `onHostDestroy`
+    private var activityLifecycleCallbacks: Application.ActivityLifecycleCallbacks? = null
+
     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
@@ -53,10 +58,13 @@ internal class ScreenDummyLayoutHelper(
         }
 
         weakInstance = WeakReference(this)
-
-        if (!(reactContext.hasCurrentActivity() && maybeInitDummyLayoutWithHeader(reactContext))) {
-            reactContext.addLifecycleEventListener(this)
-        }
+        maybeInitDummyLayoutWithHeader(reactContext)
+        // We register as lifecycleEventListener to retry initialization in onHostResume if the
+        // activity wasn't yet available. Once initialization succeeds, onHostResume removes this listener
+        // from that point on cleanup is handled exclusively by ActivityLifecycleCallbacks registered on the
+        // Application. onHostDestroy here acts only as a defensive fallback to unregister in the rare case
+        // where init never succeeded and the lifecycleEventListener was therefore never removed.
+        reactContext.addLifecycleEventListener(this)
     }
 
     /**
@@ -81,7 +89,7 @@ internal class ScreenDummyLayoutHelper(
 
         // We need to use activity here, as react context does not have theme attributes required by
         // AppBarLayout attached leading to crash.
-        val contextWithTheme =
+        val activity =
             requireNotNull(reactContext.currentActivity) {
                 "[RNScreens] Attempt to use context detached from activity. This could happen only due to race-condition."
             }
@@ -91,7 +99,9 @@ internal class ScreenDummyLayoutHelper(
             if (isLayoutInitialized) {
                 return true
             }
-            initDummyLayoutWithHeader(contextWithTheme)
+            initDummyLayoutWithHeader(activity)
+
+            registerActivityLifecycleListener(activity)
         }
         return true
     }
@@ -103,9 +113,9 @@ internal class ScreenDummyLayoutHelper(
      * to initialize the AppBarLayout.
      */
     private fun initDummyLayoutWithHeader(contextWithTheme: Context) {
-        coordinatorLayout = CoordinatorLayout(contextWithTheme)
+        val newCoordinatorLayout = CoordinatorLayout(contextWithTheme)
 
-        appBarLayout =
+        val newAppBarLayout =
             AppBarLayout(contextWithTheme).apply {
                 layoutParams =
                     CoordinatorLayout.LayoutParams(
@@ -114,7 +124,7 @@ internal class ScreenDummyLayoutHelper(
                     )
             }
 
-        toolbar =
+        val newToolbar =
             Toolbar(contextWithTheme).apply {
                 title = DEFAULT_HEADER_TITLE
                 layoutParams =
@@ -126,12 +136,16 @@ internal class ScreenDummyLayoutHelper(
             }
 
         // We know the title text view will be there, cause we've just set title.
-        defaultFontSize = ScreenStackHeaderConfig.findTitleTextViewInToolbar(toolbar)!!.textSize
-        defaultContentInsetStartWithNavigation = toolbar.contentInsetStartWithNavigation
+        val titleTextView =
+            checkNotNull(ScreenStackHeaderConfig.findTitleTextViewInToolbar(newToolbar)) {
+                "[RNScreens] Failed to find TextView in children of Toolbar"
+            }
+        defaultFontSize = titleTextView.textSize
+        defaultContentInsetStartWithNavigation = newToolbar.contentInsetStartWithNavigation
 
-        appBarLayout.addView(toolbar)
+        newAppBarLayout.addView(newToolbar)
 
-        dummyContentView =
+        val newDummyContentView =
             View(contextWithTheme).apply {
                 layoutParams =
                     CoordinatorLayout.LayoutParams(
@@ -140,11 +154,16 @@ internal class ScreenDummyLayoutHelper(
                     )
             }
 
-        coordinatorLayout.apply {
-            addView(appBarLayout)
-            addView(dummyContentView)
+        newCoordinatorLayout.apply {
+            addView(newAppBarLayout)
+            addView(newDummyContentView)
         }
 
+        coordinatorLayout = newCoordinatorLayout
+        appBarLayout = newAppBarLayout
+        toolbar = newToolbar
+        dummyContentView = newDummyContentView
+
         isLayoutInitialized = true
     }
 
@@ -152,10 +171,15 @@ internal class ScreenDummyLayoutHelper(
      * Triggers layout pass on dummy view hierarchy, taking into consideration selected
      * ScreenStackHeaderConfig props that might have impact on final header height.
      *
+     * It's called from C++ via JNI on a background thread; @Synchronized guards against concurrent `cleanUpViews`
+     * running on the main thread (activity lifecycle), which would flip `isLayoutInitialized` and clear
+     * the cache while a measurement is in progress.
+     *
      * @param fontSize font size value as passed from JS
      * @return header height in dp as consumed by Yoga
      */
     @DoNotStrip
+    @Synchronized
     private fun computeDummyLayout(
         fontSize: Int,
         isTitleEmpty: Boolean,
@@ -178,7 +202,16 @@ internal class ScreenDummyLayoutHelper(
             return cache.headerHeight
         }
 
-        val topLevelDecorView = requireActivity().window.decorView
+        // components below are always initialized and cleared together.
+        val currentCoordinatorLayout = coordinatorLayout
+        val currentAppBarLayout = appBarLayout
+        val currentToolbar = toolbar
+        val currentActivity = reactContextRef.get()?.currentActivity
+        if (currentCoordinatorLayout == null || currentAppBarLayout == null || currentToolbar == null || currentActivity == null) {
+            return 0.0f
+        }
+
+        val topLevelDecorView = currentActivity.window.decorView
         val topInset = getDecorViewTopInset(topLevelDecorView)
 
         // These dimensions are not accurate, as they do include navigation bar, however
@@ -192,42 +225,73 @@ internal class ScreenDummyLayoutHelper(
             View.MeasureSpec.makeMeasureSpec(decorViewHeight, View.MeasureSpec.EXACTLY)
 
         if (isTitleEmpty) {
-            toolbar.title = ""
-            toolbar.contentInsetStartWithNavigation = 0
+            currentToolbar.title = ""
+            currentToolbar.contentInsetStartWithNavigation = 0
         } else {
-            toolbar.title = DEFAULT_HEADER_TITLE
-            toolbar.contentInsetStartWithNavigation = defaultContentInsetStartWithNavigation
+            currentToolbar.title = DEFAULT_HEADER_TITLE
+            currentToolbar.contentInsetStartWithNavigation = defaultContentInsetStartWithNavigation
         }
 
-        val textView = ScreenStackHeaderConfig.findTitleTextViewInToolbar(toolbar)
+        val textView = ScreenStackHeaderConfig.findTitleTextViewInToolbar(currentToolbar)
         textView?.textSize =
             if (fontSize != FONT_SIZE_UNSET) fontSize.toFloat() else defaultFontSize
 
-        coordinatorLayout.measure(widthMeasureSpec, heightMeasureSpec)
+        currentCoordinatorLayout.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)
+        currentCoordinatorLayout.layout(0, 0, decorViewWidth, decorViewHeight)
 
         // Include the top inset to account for the extra padding manually applied to the CustomToolbar.
-        val totalAppBarLayoutHeight = appBarLayout.height.toFloat() + topInset
+        val totalAppBarLayoutHeight = currentAppBarLayout.height.toFloat() + topInset
 
         val headerHeight = PixelUtil.toDIPFromPixel(totalAppBarLayoutHeight)
         cache = CacheEntry(CacheKey(fontSize, isTitleEmpty), headerHeight)
         return headerHeight
     }
 
+    // We use Application.ActivityLifecycleCallbacks instead of ReactNative's LifecycleEventListener
+    // for cleanup because it is registered on the Application object directly. We're relying on the native
+    // lifecycle, rather than React's lifecycle.
+    private fun registerActivityLifecycleListener(activity: Activity) {
+        if (activityLifecycleCallbacks != null) return
+
+        activityLifecycleCallbacks =
+            object : Application.ActivityLifecycleCallbacks {
+                override fun onActivityDestroyed(destroyedActivity: Activity) {
+                    if (destroyedActivity === activity) {
+                        cleanUpViews(destroyedActivity.application)
+                    }
+                }
+
+                override fun onActivityCreated(
+                    activity: Activity,
+                    savedInstanceState: Bundle?,
+                ) = Unit
+
+                override fun onActivityStarted(activity: Activity) = Unit
+
+                override fun onActivityResumed(activity: Activity) = Unit
+
+                override fun onActivityPaused(activity: Activity) = Unit
+
+                override fun onActivityStopped(activity: Activity) = Unit
+
+                override fun onActivitySaveInstanceState(
+                    activity: Activity,
+                    outState: Bundle,
+                ) = Unit
+            }
+
+        activity.application.registerActivityLifecycleCallbacks(activityLifecycleCallbacks)
+    }
+
     private fun requireReactContext(lazyMessage: (() -> Any)? = null): ReactApplicationContext =
         requireNotNull(
             reactContextRef.get(),
             lazyMessage ?: { "[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"
 
@@ -270,6 +334,26 @@ internal class ScreenDummyLayoutHelper(
     override fun onHostDestroy() {
         reactContextRef.get()?.removeLifecycleEventListener(this)
     }
+
+    // Called from `onActivityDestroyed` on the main thread; @Synchronized guards against concurrent
+    // `computeDummyLayout` running on a JNI background thread, which could write a stale cache entry after cleanup.
+    @Synchronized
+    private fun cleanUpViews(application: Application) {
+        coordinatorLayout = null
+        appBarLayout = null
+        dummyContentView = null
+        toolbar = null
+
+        cache = CacheEntry.EMPTY
+
+        isLayoutInitialized = false
+
+        val callbacks = activityLifecycleCallbacks
+        if (callbacks != null) {
+            application.unregisterActivityLifecycleCallbacks(callbacks)
+            activityLifecycleCallbacks = null
+        }
+    }
 }
 
 private data class CacheKey(

package/android/src/main/jni/rnscreens.h

@@ -23,6 +23,9 @@
 #include <react/renderer/components/rnscreens/RNSFullWindowOverlayComponentDescriptor.h>
 #include <react/renderer/components/rnscreens/RNSTabsHostComponentDescriptor.h>
 #include <react/renderer/components/rnscreens/RNSSafeAreaViewComponentDescriptor.h>
+#include <react/renderer/components/rnscreens/RNSStackScreenComponentDescriptor.h>
+#include <react/renderer/components/rnscreens/RNSStackHeaderConfigComponentDescriptor.h>
+#include <react/renderer/components/rnscreens/RNSStackHeaderSubviewComponentDescriptor.h>
 
 namespace facebook {
 namespace react {

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#endif // ANDROID
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSSplitScreenShadowNode.h"
+
+namespace facebook::react {
+
+class RNSSplitScreenComponentDescriptor final
+    : public ConcreteComponentDescriptor<RNSSplitScreenShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    react_native_assert(dynamic_cast<RNSSplitScreenShadowNode *>(&shadowNode));
+    auto &splitScreenShadowNode =
+        static_cast<RNSSplitScreenShadowNode &>(shadowNode);
+
+    react_native_assert(
+        dynamic_cast<YogaLayoutableShadowNode *>(&splitScreenShadowNode));
+    auto &layoutableShadowNode =
+        static_cast<YogaLayoutableShadowNode &>(splitScreenShadowNode);
+
+    auto state =
+        std::static_pointer_cast<const RNSSplitScreenShadowNode::ConcreteState>(
+            shadowNode.getState());
+    auto stateData = state->getData();
+
+    if (stateData.frameSize.width != 0 && stateData.frameSize.height != 0) {
+      layoutableShadowNode.setSize(stateData.frameSize);
+    }
+
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,13 @@
+#include "RNSSplitScreenShadowNode.h"
+
+namespace facebook::react {
+
+extern const char RNSSplitScreenComponentName[] = "RNSSplitScreen";
+
+Point RNSSplitScreenShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
+  auto stateData = getStateData();
+  return stateData.contentOffset;
+}
+
+} // namespace facebook::react

package/common/cpp/react/renderer/components/rnscreens/{RNSSplitViewScreenShadowNode.h → RNSSplitScreenShadowNode.h}

@@ -5,19 +5,19 @@
 #include <react/renderer/components/rnscreens/Props.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/core/LayoutContext.h>
-#include "RNSSplitViewScreenState.h"
+#include "RNSSplitScreenState.h"
 
 namespace facebook::react {
 
-JSI_EXPORT extern const char RNSSplitViewScreenComponentName[];
+JSI_EXPORT extern const char RNSSplitScreenComponentName[];
 
 using ConcreteViewShadowNodeSuperType = ConcreteViewShadowNode<
-    RNSSplitViewScreenComponentName,
-    RNSSplitViewScreenProps,
-    RNSSplitViewScreenEventEmitter,
-    RNSSplitViewScreenState>;
+    RNSSplitScreenComponentName,
+    RNSSplitScreenProps,
+    RNSSplitScreenEventEmitter,
+    RNSSplitScreenState>;
 
-class JSI_EXPORT RNSSplitViewScreenShadowNode final
+class JSI_EXPORT RNSSplitScreenShadowNode final
     : public ConcreteViewShadowNodeSuperType {
  public:
   using ConcreteViewShadowNode::ConcreteViewShadowNode;

package/common/cpp/react/renderer/components/rnscreens/{RNSSplitViewScreenState.h → RNSSplitScreenState.h}

@@ -8,20 +8,20 @@
 
 namespace facebook::react {
 
-class JSI_EXPORT RNSSplitViewScreenState final {
+class JSI_EXPORT RNSSplitScreenState final {
  public:
-  using Shared = std::shared_ptr<const RNSSplitViewScreenState>;
+  using Shared = std::shared_ptr<const RNSSplitScreenState>;
 
-  RNSSplitViewScreenState() {};
-  RNSSplitViewScreenState(Size frameSize_, Point contentOffset_)
+  RNSSplitScreenState() {};
+  RNSSplitScreenState(Size frameSize_, Point contentOffset_)
       : frameSize(frameSize_), contentOffset(contentOffset_) {};
 
   const Size frameSize{};
   const Point contentOffset{};
 
 #if defined(ANDROID)
-  RNSSplitViewScreenState(
-      const RNSSplitViewScreenState &previousState,
+  RNSSplitScreenState(
+      const RNSSplitScreenState &previousState,
       folly::dynamic data) {}
   folly::dynamic getDynamic() const {
     return {};

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#endif // ANDROID
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSStackHeaderConfigShadowNode.h"
+
+namespace facebook::react {
+
+class RNSStackHeaderConfigComponentDescriptor final
+    : public ConcreteComponentDescriptor<RNSStackHeaderConfigShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+#ifdef ANDROID
+    react_native_assert(
+        dynamic_cast<RNSStackHeaderConfigShadowNode *>(&shadowNode));
+    auto &configShadowNode =
+        static_cast<RNSStackHeaderConfigShadowNode &>(shadowNode);
+    react_native_assert(
+        dynamic_cast<YogaLayoutableShadowNode *>(&configShadowNode));
+    auto &layoutableShadowNode =
+        static_cast<YogaLayoutableShadowNode &>(configShadowNode);
+
+    auto state = std::static_pointer_cast<
+        const RNSStackHeaderConfigShadowNode::ConcreteState>(
+        shadowNode.getState());
+    auto stateData = state->getData();
+
+    if (stateData.frameSize.width != 0 && stateData.frameSize.height != 0) {
+      layoutableShadowNode.setSize(
+          Size{stateData.frameSize.width, stateData.frameSize.height});
+    }
+#endif // ANDROID
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,21 @@
+#include "RNSStackHeaderConfigShadowNode.h"
+
+namespace facebook::react {
+
+#if !defined(ANDROID)
+extern const char RNSStackHeaderConfigComponentName[] =
+    "RNSStackHeaderConfigIOS";
+#else // !defined(ANDROID)
+extern const char RNSStackHeaderConfigComponentName[] =
+    "RNSStackHeaderConfigAndroid";
+#endif // !defined(ANDROID)
+
+#ifdef ANDROID
+Point RNSStackHeaderConfigShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
+  auto stateData = getStateData();
+  return stateData.contentOffset;
+}
+#endif // ANDROID
+
+} // namespace facebook::react