react-native-screens 5.0.0-alpha.3 → 5.0.0-alpha.4

package/android/src/main/java/com/swmansion/rnscreens/stack/header/StackHeaderCoordinatorLayout.kt

@@ -21,7 +21,9 @@ import com.swmansion.rnscreens.stack.header.config.StackHeaderConfigurationObser
 import com.swmansion.rnscreens.stack.header.config.StackHeaderConfigurationProviding
 import com.swmansion.rnscreens.stack.header.config.StackHeaderDelegate
 import com.swmansion.rnscreens.stack.header.config.StackHeaderInvalidationFlags
+import com.swmansion.rnscreens.stack.host.StackUpdateBatchStateProviding
 import com.swmansion.rnscreens.stack.screen.StackScreen
+import java.lang.ref.WeakReference
 
 /**
  * Root CoordinatorLayout for a screen's header: hosts the app bar and the
@@ -33,6 +35,8 @@ internal class StackHeaderCoordinatorLayout(
     context: Context,
     internal val stackScreen: StackScreen,
     private val canNavigateBack: Boolean,
+    private val updateBatchStateProvider: WeakReference<StackUpdateBatchStateProviding>,
+    parentColorSchemeProvider: WeakReference<ColorSchemeProviding>,
     private val backPressHandler: StackHeaderBackPressHandler,
 ) : CoordinatorLayout(context),
     ColorSchemeProviding {
@@ -63,8 +67,13 @@ internal class StackHeaderCoordinatorLayout(
 
         if (provider != null) {
             provider.setConfigurationObserver(configObserver)
-            processUpdate(provider)
+            // A freshly adopted config is fully dirty by construction: this
+            // coordinator has applied nothing of it yet, regardless of what a
+            // previous (destroyed) coordinator consumed.
+            invalidate(StackHeaderInvalidationFlags.ALL)
+            flushPendingUpdates()
         } else {
+            pendingFlags = StackHeaderInvalidationFlags.NONE
             removeHeader()
         }
     }
@@ -74,8 +83,9 @@ internal class StackHeaderCoordinatorLayout(
     // region Configuration observer
 
     private val configObserver =
-        object : StackHeaderConfigurationObserver {
-            override fun onConfigChanged(config: StackHeaderConfigurationProviding) = processUpdate(config)
+        StackHeaderConfigurationObserver { flags ->
+            invalidate(flags)
+            flushPendingUpdates()
         }
 
     // endregion
@@ -110,11 +120,12 @@ internal class StackHeaderCoordinatorLayout(
         StackHeaderFrameSynchronizer.sync(appBar, provider, delegate)
     }
 
-    // Tracks whether the app bar is currently scrolled to its fully collapsed offset. Used to work
-    // around a Material offset bug when the title/subtitle changes at runtime — see
-    // StackHeaderApplicator.applyTitleAndSubtitle. This should be equivalent to Material's
-    // `collapsingTitleHelper.getExpansionFraction() == 1f` condition.
-    private var isAppBarFullyCollapsed = false
+    // Tracks whether the app bar is currently scrolled to its fully collapsed offset, so
+    // processUpdate can preserve the collapsed resting state across header updates (rebuilds and
+    // re-measures start expanded). This should be equivalent to Material's
+    // `collapsingTitleHelper.getExpansionFraction() == 1f` condition. `null` means unknown: no
+    // offset has been observed since the header was last removed.
+    private var isAppBarFullyCollapsed: Boolean? = null
 
     private fun evaluateCollapseState(
         appBar: AppBarLayout,
@@ -126,6 +137,26 @@ internal class StackHeaderCoordinatorLayout(
 
     // endregion
 
+    // region Layout direction
+
+    // Direction the header was last built against. In order to ensure correct
+    // layout and appearance (e.g. back button arrow direction), we rebuild the
+    // header on layout direction change.
+    private var builtLayoutDirection: Int? = null
+
+    override fun onRtlPropertiesChanged(layoutDirection: Int) {
+        super.onRtlPropertiesChanged(layoutDirection)
+
+        if (builtLayoutDirection == null || builtLayoutDirection == layoutDirection) {
+            return
+        }
+
+        invalidate(StackHeaderInvalidationFlags.STRUCTURE)
+        flushPendingUpdates()
+    }
+
+    // endregion
+
     // region Header updates
 
     private val wrappedContext =
@@ -142,69 +173,75 @@ internal class StackHeaderCoordinatorLayout(
         backPressHandler.handleHeaderBackButtonPress(stackScreen)
     }
 
-    private fun processUpdate(
-        provider: StackHeaderConfigurationProviding,
-        forcedFlags: StackHeaderInvalidationFlags = StackHeaderInvalidationFlags.NONE,
-    ) {
-        val effectiveFlags = provider.invalidationFlags or forcedFlags
-        val needsRebuild = effectiveFlags.needsRebuild
+    private var pendingFlags = StackHeaderInvalidationFlags.NONE
+
+    private fun invalidate(flags: StackHeaderInvalidationFlags) {
+        pendingFlags = pendingFlags or flags
+    }
+
+    internal fun flushPendingUpdates() {
+        val provider = currentProvider ?: return
+        if (pendingFlags.isEmpty) return
+        // Hold the flush while more updates may arrive in the current batch; the container
+        // flushes when the batch ends.
+        if (updateBatchStateProvider.get()?.isUpdatePending == true) return
+        // While detached from window, only accumulate: onAttachedToWindow flushes once, after the
+        // color scheme is resolved, so the header is built under the right theme.
+        if (!isAttachedToWindow) return
+        processUpdate(provider)
+    }
+
+    private fun processUpdate(provider: StackHeaderConfigurationProviding) {
+        val flags = pendingFlags
+        pendingFlags = StackHeaderInvalidationFlags.NONE
+
+        val needsRebuild = flags.needsRebuild
+        val wasFullyCollapsed = isAppBarFullyCollapsed
+
         if (needsRebuild) {
-            resetHeader()
             if (provider.hidden) {
-                removeContentBehavior()
-                requestLayout()
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.ALL)
+                removeHeader()
                 return
             }
 
+            resetHeader()
             val appBar = applicator.rebuild(this, provider)
             appBarLayout = appBar
+            builtLayoutDirection = layoutDirection
             attachAppBarListeners(appBar)
-
-            // If config needs to be rebuilt, all other flags must be invalidated as well.
-            provider.clearInvalidationFlags(
-                StackHeaderInvalidationFlags.STRUCTURE or StackHeaderInvalidationFlags.SUBVIEWS,
-            )
         }
 
         val appBar = appBarLayout
         if (appBar != null) {
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.TITLE)) {
-                applicator.applyTitleAndSubtitle(appBar, provider, isAppBarFullyCollapsed)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.TITLE)
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TITLE)) {
+                applicator.applyTitleAndSubtitle(appBar, provider)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.TITLE_APPEARANCE)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TITLE_APPEARANCE)) {
                 applicator.applyTitleAndSubtitleAppearance(appBar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.TITLE_APPEARANCE)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.TITLE_POSITIONING)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TITLE_POSITIONING)) {
                 applicator.applyTitlePositioning(appBar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.TITLE_POSITIONING)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.CONTENT_INSETS)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.CONTENT_INSETS)) {
                 applicator.applyContentInsets(appBar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.CONTENT_INSETS)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.BACK_BUTTON)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.BACK_BUTTON)) {
                 applicator.applyBackButton(appBar.toolbar, provider, canNavigateBack, onNavigationIconClick)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.BACK_BUTTON)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.SCROLL_FLAGS)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.SCROLL_FLAGS)) {
                 applicator.applyScrollFlags(appBar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.SCROLL_FLAGS)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.BACKGROUND_COLORS)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.BACKGROUND_COLORS)) {
                 applicator.applyBackgroundColors(appBar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.BACKGROUND_COLORS)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)) {
                 // Lift-on-scroll is disabled in transparent mode: there is no content
                 // scrolling behavior installed and the app bar overlays the content.
                 applicator.applyLiftOnScroll(
@@ -212,28 +249,43 @@ internal class StackHeaderCoordinatorLayout(
                     enabled = provider.liftOnScroll && !provider.transparent,
                     targetScrollView = stackScreen.findContentScrollView(),
                 )
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.TOOLBAR_MENU)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TOOLBAR_MENU)) {
                 provider.toolbarMenuController.attach(appBar.toolbar)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.TOOLBAR_MENU)
             }
 
-            if (needsRebuild || effectiveFlags.containsAny(StackHeaderInvalidationFlags.OVERFLOW_ICON)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.OVERFLOW_ICON)) {
                 applicator.applyOverflowIcon(appBar.toolbar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.OVERFLOW_ICON)
+            }
+
+            // A rebuilt or re-measured app bar starts expanded; re-assert the fully-collapsed
+            // resting state so a scrolled-down screen doesn't jump. When the state is unknown
+            // (the header was removed — hidden, config detach), infer it from the content:
+            // scrolled content implies the bar was collapsed. A pending action, so it wins
+            // over applyScrollFlags' expand snap, and it resolves against the new configuration —
+            // degrading to expanded when the header can no longer collapse. Fractional offsets
+            // reset to expanded.
+            if (wasFullyCollapsed ?: isContentScrolled()) {
+                appBar.setExpanded(false, false)
             }
         }
 
         onMaybeHeaderLayoutChanged()
     }
 
+    // If the scroll view hasn't reached the top, we consider it scrolled.
+    private fun isContentScrolled() = stackScreen.findContentScrollView()?.canScrollVertically(-1) == true
+
     // endregion
 
     // region Color scheme
 
-    private val colorSchemeCoordinator = ColorSchemeCoordinator()
+    // As the fragment's root view, this layout gets reparented into the container's
+    // ViewGroupOverlay for exit transitions, where a parent walk finds no provider -
+    // hence the ownership-injected one.
+    private val colorSchemeCoordinator =
+        ColorSchemeCoordinator().apply { explicitParentProvider = parentColorSchemeProvider }
 
     // Night mode the header visuals were last applied against. Unlike the coordinator's
     // internal dedupe (reset on every setup()), this survives detach/reattach, skipping
@@ -252,7 +304,14 @@ internal class StackHeaderCoordinatorLayout(
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
+        // Resolve the color scheme before flushing, so a deferred first build happens under the
+        // pinned theme (a scheme change inside setup() flushes by itself; the trailing flush then
+        // no-ops).
         colorSchemeCoordinator.setup(this) { applyUiNightMode(it) }
+        // AppBarLayout clears its liftOnScrollTargetView on window detach and never re-resolves
+        // it; re-apply on every attach.
+        invalidate(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
+        flushPendingUpdates()
     }
 
     override fun onDetachedFromWindow() {
@@ -274,18 +333,11 @@ internal class StackHeaderCoordinatorLayout(
         }
 
         appliedUiNightMode = uiNightMode
-        currentProvider?.let {
-            // A rebuild is forced because MaterialToolbar snapshots its theme at construction:
-            // ripples, the overflow popup and menu item views resolve from that frozen copy, so
-            // only view recreation refreshes them.
-            val wasFullyCollapsed = isAppBarFullyCollapsed
-            processUpdate(it, forcedFlags = StackHeaderInvalidationFlags.STRUCTURE)
-            // The rebuilt app bar starts expanded; restore the fully-collapsed resting state
-            // so a scrolled-down screen doesn't jump. Fractional offsets reset.
-            if (wasFullyCollapsed) {
-                appBarLayout?.setExpanded(false, false)
-            }
-        }
+        // A rebuild is needed because MaterialToolbar snapshots its theme at construction:
+        // ripples, the overflow popup and menu item views resolve from that frozen copy, so
+        // only view recreation refreshes them.
+        invalidate(StackHeaderInvalidationFlags.STRUCTURE)
+        flushPendingUpdates()
     }
 
     // endregion
@@ -298,13 +350,13 @@ internal class StackHeaderCoordinatorLayout(
             removeView(it)
         }
         appBarLayout = null
-        // A rebuilt header starts fully expanded; drop any stale collapsed state from the old one.
-        isAppBarFullyCollapsed = false
         currentProvider?.toolbarMenuController?.detach()
     }
 
     private fun removeHeader() {
         resetHeader()
+        isAppBarFullyCollapsed = null
+        builtLayoutDirection = null
         removeContentBehavior()
         requestLayout()
     }
@@ -383,6 +435,7 @@ internal class StackHeaderCoordinatorLayout(
     internal fun tearDown() {
         colorSchemeCoordinator.teardown()
 
+        pendingFlags = StackHeaderInvalidationFlags.NONE
         removeHeader()
 
         stackScreenWrapper.removeView(stackScreen)

package/android/src/main/java/com/swmansion/rnscreens/stack/header/appbar/StackHeaderAppBarLayout.kt

@@ -117,7 +117,7 @@ internal sealed class StackHeaderAppBarLayout(
         collapsedTitleGravityMode: StackHeaderCollapsedTitleGravityMode,
     ) : StackHeaderAppBarLayout(context) {
         override val toolbar =
-            MaterialToolbar(context).apply {
+            StackHeaderToolbar(context).apply {
                 elevation = 0f
                 layoutParams =
                     CollapsingToolbarLayout

package/android/src/main/java/com/swmansion/rnscreens/stack/header/appbar/StackHeaderToolbar.kt

@@ -0,0 +1,74 @@
+package com.swmansion.rnscreens.stack.header.appbar
+
+import android.content.Context
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup.LayoutParams.MATCH_PARENT
+import com.google.android.material.appbar.MaterialToolbar
+import com.swmansion.rnscreens.stack.header.subview.StackHeaderSubview
+
+/**
+ * Toolbar of a collapsing header. It exists to change the gravity of the
+ * placeholder view that CollapsingToolbarLayout adds to the toolbar, so that
+ * custom subview layout under RTL is correct.
+ *
+ * CollapsingToolbarLayout tracks the area the collapsed title is drawn in by
+ * adding a placeholder view with MATCH_PARENT layout params to the toolbar -
+ * the view itself doesn't draw the title, it is only measured. The placeholder
+ * inherits the toolbar's default START gravity, which is the same layout group
+ * our leading subview goes into. The toolbar walks that group in reverse child
+ * order under RTL, so the placeholder is positioned first and takes over the
+ * whole layout cursor, leaving the collapsed title drawn over the trailing
+ * subview and the toolbar menu. CENTER_HORIZONTAL moves it to the group the
+ * toolbar positions last, clamped into what the other children left over, which
+ * is the correct rect in both directions.
+ *
+ * See https://github.com/material-components/material-components-android/issues/1867.
+ */
+internal class StackHeaderToolbar(
+    context: Context,
+) : MaterialToolbar(context) {
+    private var hasCollapsedTitlePlaceholder = false
+
+    override fun onViewAdded(child: View) {
+        super.onViewAdded(child)
+
+        val params = child.layoutParams as LayoutParams
+        if (!isCollapsedTitlePlaceholder(child, params)) {
+            return
+        }
+
+        params.gravity = Gravity.CENTER_HORIZONTAL or Gravity.CENTER_VERTICAL
+        hasCollapsedTitlePlaceholder = true
+    }
+
+    /**
+     * The placeholder is not identifiable by type - it is a plain [View] - so it is recognized by
+     * its size instead. Every view the toolbar builds for itself (navigation & collapse buttons,
+     * menu, logo, expanded action view) is WRAP_CONTENT, and so are the subviews we add, which
+     * leaves a MATCH_PARENT child of a foreign type as the placeholder and nothing else.
+     */
+    private fun isCollapsedTitlePlaceholder(
+        child: View,
+        params: LayoutParams,
+    ): Boolean =
+        child !is StackHeaderSubview &&
+            params.width == MATCH_PARENT &&
+            params.height == MATCH_PARENT
+
+    override fun onLayout(
+        changed: Boolean,
+        l: Int,
+        t: Int,
+        r: Int,
+        b: Int,
+    ) {
+        // The placeholder is added from CollapsingToolbarLayout.onMeasure, which always precedes
+        // our layout. Holds as long as the collapsing layout keeps its title enabled.
+        check(hasCollapsedTitlePlaceholder) {
+            "[RNScreens] CollapsingToolbarLayout did not add its collapsed title placeholder."
+        }
+
+        super.onLayout(changed, l, t, r, b)
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/stack/header/config/StackHeaderConfig.kt

@@ -2,19 +2,13 @@ package com.swmansion.rnscreens.stack.header.config
 
 import android.annotation.SuppressLint
 import android.graphics.drawable.Drawable
-import android.util.LayoutDirection
 import android.view.Gravity
-import com.facebook.react.bridge.UIManager
-import com.facebook.react.bridge.UIManagerListener
-import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.view.ReactViewGroup
 import com.swmansion.rnscreens.common.ShadowStateProxy
 import com.swmansion.rnscreens.common.text.ReactTextAppearance
 import com.swmansion.rnscreens.helpers.IconResolution
 import com.swmansion.rnscreens.helpers.PropIconResolver
-import com.swmansion.rnscreens.helpers.getFabricUIManagerNotNull
 import com.swmansion.rnscreens.helpers.resolveImage
 import com.swmansion.rnscreens.stack.header.subview.OnStackHeaderSubviewChangeListener
 import com.swmansion.rnscreens.stack.header.subview.StackHeaderSubview
@@ -27,7 +21,6 @@ import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMen
 import java.lang.ref.WeakReference
 import kotlin.properties.Delegates
 
-@OptIn(UnstableReactNativeAPI::class)
 @SuppressLint("ViewConstructor")
 internal class StackHeaderConfig(
     val reactContext: ThemedReactContext,
@@ -35,14 +28,7 @@ internal class StackHeaderConfig(
     StackHeaderConfigurationProviding,
     StackHeaderDelegate,
     StackHeaderToolbarMenuDelegate,
-    OnStackHeaderSubviewChangeListener,
-    UIManagerListener {
-    init {
-        UIManagerHelper
-            .getFabricUIManagerNotNull(reactContext)
-            .addUIManagerEventListener(this)
-    }
-
+    OnStackHeaderSubviewChangeListener {
     // region Handling configuration changes
 
     private var configObserver: StackHeaderConfigurationObserver? = null
@@ -51,22 +37,8 @@ internal class StackHeaderConfig(
         configObserver = observer
     }
 
-    override var invalidationFlags = StackHeaderInvalidationFlags.ALL
-
-    override fun clearInvalidationFlags(flags: StackHeaderInvalidationFlags) {
-        invalidationFlags = invalidationFlags.clearing(flags)
-    }
-
     private fun invalidate(flags: StackHeaderInvalidationFlags) {
-        invalidationFlags = invalidationFlags or flags
-    }
-
-    private fun flushUpdates() {
-        if (configObserver == null || invalidationFlags.isEmpty) {
-            return
-        }
-
-        configObserver?.onConfigChanged(this)
+        configObserver?.onInvalidated(flags)
     }
 
     // endregion
@@ -188,9 +160,6 @@ internal class StackHeaderConfig(
 
     private fun invalidateTextAppearance() = invalidate(StackHeaderInvalidationFlags.TITLE_APPEARANCE)
 
-    override val isRTL: Boolean
-        get() = layoutDirection == LayoutDirection.RTL
-
     // endregion
 
     // region Content scroll view
@@ -203,9 +172,6 @@ internal class StackHeaderConfig(
      */
     internal fun onContentScrollViewChanged() {
         invalidate(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
-        if (!isInsideMountTransaction) {
-            flushUpdates()
-        }
     }
 
     // endregion
@@ -226,12 +192,7 @@ internal class StackHeaderConfig(
         ) { result ->
             when (result) {
                 IconResolution.Unchanged -> Unit
-                is IconResolution.Resolved -> {
-                    backButtonIcon = result.drawable
-                    if (!isInsideMountTransaction) {
-                        flushUpdates()
-                    }
-                }
+                is IconResolution.Resolved -> backButtonIcon = result.drawable
             }
         }
     }
@@ -253,12 +214,7 @@ internal class StackHeaderConfig(
         ) { result ->
             when (result) {
                 IconResolution.Unchanged -> Unit
-                is IconResolution.Resolved -> {
-                    overflowIcon = result.drawable
-                    if (!isInsideMountTransaction) {
-                        flushUpdates()
-                    }
-                }
+                is IconResolution.Resolved -> overflowIcon = result.drawable
             }
         }
     }
@@ -407,35 +363,10 @@ internal class StackHeaderConfig(
 
     // endregion
 
-    // region UIManagerListener
-
-    private var isInsideMountTransaction = false
-
-    override fun willMountItems(uiManager: UIManager) {
-        isInsideMountTransaction = true
-    }
-
-    override fun didMountItems(uiManager: UIManager) {
-        isInsideMountTransaction = false
-        flushUpdates()
-    }
-
-    override fun willDispatchViewUpdates(uiManager: UIManager) = Unit
-
-    override fun didDispatchMountItems(uiManager: UIManager) = Unit
-
-    override fun didScheduleMountItems(uiManager: UIManager) = Unit
-
-    // endregion
-
     // region Teardown
 
     internal fun tearDown() {
-        UIManagerHelper
-            .getFabricUIManagerNotNull(reactContext)
-            .removeUIManagerEventListener(this)
         toolbarMenuController.tearDown()
-        invalidationFlags = StackHeaderInvalidationFlags.NONE
         configObserver = null
     }
 

package/android/src/main/java/com/swmansion/rnscreens/stack/header/config/StackHeaderConfigurationObserver.kt

@@ -1,5 +1,8 @@
 package com.swmansion.rnscreens.stack.header.config
 
-internal interface StackHeaderConfigurationObserver {
-    fun onConfigChanged(config: StackHeaderConfigurationProviding)
+internal fun interface StackHeaderConfigurationObserver {
+    /**
+     * Reports that the parts of the configuration described by [flags] changed.
+     */
+    fun onInvalidated(flags: StackHeaderInvalidationFlags)
 }

package/android/src/main/java/com/swmansion/rnscreens/stack/header/config/StackHeaderConfigurationProviding.kt

@@ -55,11 +55,5 @@ internal interface StackHeaderConfigurationProviding {
     val expandedSubtitleAppearance: TextAppearance
     val collapsedSubtitleAppearance: TextAppearance
 
-    val isRTL: Boolean
-
-    val invalidationFlags: StackHeaderInvalidationFlags
-
-    fun clearInvalidationFlags(flags: StackHeaderInvalidationFlags)
-
     fun setConfigurationObserver(observer: StackHeaderConfigurationObserver?)
 }

package/android/src/main/java/com/swmansion/rnscreens/stack/header/config/StackHeaderInvalidationFlags.kt

@@ -18,19 +18,15 @@ internal value class StackHeaderInvalidationFlags(
         val TITLE_APPEARANCE = StackHeaderInvalidationFlags(1 shl 9)
         val CONTENT_INSETS = StackHeaderInvalidationFlags(1 shl 10)
         val BACKGROUND_COLORS = StackHeaderInvalidationFlags(1 shl 11)
-        val APPEARANCE =
-            TITLE or BACK_BUTTON or OVERFLOW_ICON or TITLE_POSITIONING or TITLE_APPEARANCE or CONTENT_INSETS or BACKGROUND_COLORS
-        val ALL = STRUCTURE or SUBVIEWS or APPEARANCE or SCROLL_FLAGS or TOOLBAR_MENU or LIFT_ON_SCROLL
+        val ALL =
+            STRUCTURE or SUBVIEWS or TITLE or BACK_BUTTON or SCROLL_FLAGS or TOOLBAR_MENU or LIFT_ON_SCROLL or
+                OVERFLOW_ICON or TITLE_POSITIONING or TITLE_APPEARANCE or CONTENT_INSETS or BACKGROUND_COLORS
     }
 
     infix fun or(other: StackHeaderInvalidationFlags) = StackHeaderInvalidationFlags(raw or other.raw)
 
     fun containsAny(flags: StackHeaderInvalidationFlags) = flags.raw != 0 && (raw and flags.raw) != 0
 
-    fun clearing(flags: StackHeaderInvalidationFlags) = StackHeaderInvalidationFlags(raw and flags.raw.inv())
-
-    val isNotEmpty get() = raw != 0
-
     val isEmpty get() = raw == 0
 
     val needsRebuild get() = containsAny(STRUCTURE or SUBVIEWS)

package/android/src/main/java/com/swmansion/rnscreens/stack/host/FragmentOperation.kt

@@ -14,6 +14,7 @@ internal class AddAndSetAsPrimaryOp(
     val fragment: StackScreenFragment,
     val containerViewId: Int,
     val addToBackStack: Boolean,
+    val coveredFragment: StackScreenFragment?,
     val allowStateLoss: Boolean = true,
 ) : FragmentOperation() {
     override fun execute(

package/android/src/main/java/com/swmansion/rnscreens/stack/host/FragmentOperationExecutor.kt

@@ -2,7 +2,7 @@ package com.swmansion.rnscreens.stack.host
 
 import androidx.fragment.app.FragmentManager
 import androidx.fragment.app.FragmentTransaction
-import com.swmansion.rnscreens.helpers.createTransactionWithReordering
+import com.swmansion.rnscreens.ext.createTransactionWithReordering
 
 internal class FragmentOperationExecutor {
     internal fun executeOperations(
@@ -26,6 +26,7 @@ internal class FragmentOperationExecutor {
                 tx.addToBackStack(op.fragment.stackScreen.screenKey)
             }
             tx.add(op.containerViewId, op.fragment)
+            op.coveredFragment?.let { tx.detach(it) }
             tx.setPrimaryNavigationFragment(op.fragment)
             commitTransaction(tx, op.allowStateLoss)
         }