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

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

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

@@ -0,0 +1,33 @@
+#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 "RNSStackHeaderConfigState.h"
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char RNSStackHeaderConfigComponentName[];
+
+class JSI_EXPORT RNSStackHeaderConfigShadowNode final
+    : public ConcreteViewShadowNode<
+          RNSStackHeaderConfigComponentName,
+#if !defined(ANDROID)
+          RNSStackHeaderConfigIOSProps,
+          RNSStackHeaderConfigIOSEventEmitter,
+#else // !defined(ANDROID)
+          RNSStackHeaderConfigAndroidProps,
+          RNSStackHeaderConfigAndroidEventEmitter,
+#endif // !defined(ANDROID)
+          RNSStackHeaderConfigState> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  using StateData = ConcreteViewShadowNode::ConcreteStateData;
+
+#ifdef ANDROID
+  Point getContentOriginOffset(bool includeTransform) const override;
+#endif // ANDROID
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,13 @@
+#include "RNSStackHeaderConfigState.h"
+
+namespace facebook::react {
+
+#ifdef ANDROID
+folly::dynamic RNSStackHeaderConfigState::getDynamic() const {
+  return folly::dynamic::object("frameWidth", frameSize.width)(
+      "frameHeight", frameSize.height)("contentOffsetX", contentOffset.x)(
+      "contentOffsetY", contentOffset.y);
+}
+#endif // ANDROID
+
+} // namespace facebook::react

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

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif // ANDROID
+
+namespace facebook::react {
+
+class JSI_EXPORT RNSStackHeaderConfigState final {
+ public:
+  using Shared = std::shared_ptr<const RNSStackHeaderConfigState>;
+
+  RNSStackHeaderConfigState() {}
+
+#ifdef ANDROID
+  RNSStackHeaderConfigState(
+      RNSStackHeaderConfigState const &previousState,
+      folly::dynamic data)
+      : frameSize(
+            Size{
+                (Float)data["frameWidth"].getDouble(),
+                (Float)data["frameHeight"].getDouble()}),
+        contentOffset(
+            Point{
+                (Float)data["contentOffsetX"].getDouble(),
+                (Float)data["contentOffsetY"].getDouble()}) {}
+
+  Size frameSize{};
+  Point contentOffset{};
+
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  }
+#endif // ANDROID
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "RNSStackHeaderSubviewShadowNode.h"
+
+namespace facebook::react {
+
+class RNSStackHeaderSubviewComponentDescriptor final
+    : public ConcreteComponentDescriptor<RNSStackHeaderSubviewShadowNode> {
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,30 @@
+#include "RNSStackHeaderSubviewShadowNode.h"
+
+namespace facebook::react {
+
+extern const char RNSStackHeaderSubviewComponentName[] =
+    "RNSStackHeaderSubviewAndroid";
+
+#ifdef ANDROID
+Point RNSStackHeaderSubviewShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
+  auto stateData = getStateData();
+  return stateData.contentOffset;
+}
+
+void RNSStackHeaderSubviewShadowNode::layout(
+    facebook::react::LayoutContext layoutContext) {
+  YogaLayoutableShadowNode::layout(layoutContext);
+  applyFrameCorrections();
+}
+
+// Subviews are reparented into native Toolbar which handles positioning via
+// gravity (START/END). We force x=0 so that Fabric doesn't override the
+// Toolbar's layout with Yoga-computed RTL coordinates.
+void RNSStackHeaderSubviewShadowNode::applyFrameCorrections() {
+  ensureUnsealed();
+  layoutMetrics_.frame.origin.x = 0;
+}
+#endif // ANDROID
+
+} // namespace facebook::react

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

@@ -0,0 +1,37 @@
+#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 "RNSStackHeaderSubviewState.h"
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char RNSStackHeaderSubviewComponentName[];
+
+class JSI_EXPORT RNSStackHeaderSubviewShadowNode final
+    : public ConcreteViewShadowNode<
+          RNSStackHeaderSubviewComponentName,
+          RNSStackHeaderSubviewAndroidProps,
+          RNSStackHeaderSubviewAndroidEventEmitter,
+          RNSStackHeaderSubviewState> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  using StateData = ConcreteViewShadowNode::ConcreteStateData;
+
+#ifdef ANDROID
+#pragma mark - ShadowNode overrides
+
+  Point getContentOriginOffset(bool includeTransform) const override;
+
+  void layout(LayoutContext layoutContext) override;
+
+#pragma mark - Custom interface
+ private:
+  void applyFrameCorrections();
+#endif // ANDROID
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,12 @@
+#include "RNSStackHeaderSubviewState.h"
+
+namespace facebook::react {
+
+#ifdef ANDROID
+folly::dynamic RNSStackHeaderSubviewState::getDynamic() const {
+  return folly::dynamic::object("contentOffsetX", contentOffset.x)(
+      "contentOffsetY", contentOffset.y);
+}
+#endif // ANDROID
+
+} // namespace facebook::react