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

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

@@ -2,16 +2,18 @@ package com.swmansion.rnscreens.stack.header
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.util.Log
+import android.content.res.Configuration
+import android.os.Parcelable
+import android.util.SparseArray
 import android.view.ViewGroup.LayoutParams.MATCH_PARENT
 import android.widget.FrameLayout
-import androidx.activity.OnBackPressedDispatcherOwner
 import androidx.appcompat.view.ContextThemeWrapper
 import androidx.coordinatorlayout.widget.CoordinatorLayout
-import com.facebook.react.bridge.ReactContext
 import com.google.android.material.R
 import com.google.android.material.appbar.AppBarLayout
-import com.google.android.material.appbar.MaterialToolbar
+import com.swmansion.rnscreens.common.colorscheme.ColorSchemeCoordinator
+import com.swmansion.rnscreens.common.colorscheme.ColorSchemeListener
+import com.swmansion.rnscreens.common.colorscheme.ColorSchemeProviding
 import com.swmansion.rnscreens.stack.header.appbar.StackHeaderAppBarLayout
 import com.swmansion.rnscreens.stack.header.appbar.StackHeaderScrollingViewBehavior
 import com.swmansion.rnscreens.stack.header.config.OnHeaderConfigurationAttachListener
@@ -19,10 +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.header.toolbar.StackHeaderToolbarMenuApplicator
-import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuSelectionController
-import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMenuElementUpdate
+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
@@ -34,7 +35,11 @@ internal class StackHeaderCoordinatorLayout(
     context: Context,
     internal val stackScreen: StackScreen,
     private val canNavigateBack: Boolean,
-) : CoordinatorLayout(context) {
+    private val updateBatchStateProvider: WeakReference<StackUpdateBatchStateProviding>,
+    parentColorSchemeProvider: WeakReference<ColorSchemeProviding>,
+    private val backPressHandler: StackHeaderBackPressHandler,
+) : CoordinatorLayout(context),
+    ColorSchemeProviding {
     // region Config attach / detach
 
     private var currentProvider: StackHeaderConfigurationProviding? = null
@@ -52,15 +57,23 @@ internal class StackHeaderCoordinatorLayout(
         delegate: StackHeaderDelegate?,
     ) {
         // Disconnect old config to prevent spurious updates from a detached config.
-        currentProvider?.setConfigurationObserver(null)
+        currentProvider?.let {
+            it.setConfigurationObserver(null)
+            it.toolbarMenuController.detach()
+        }
 
         currentProvider = provider
         currentDelegate = delegate
 
         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()
         }
     }
@@ -70,36 +83,9 @@ internal class StackHeaderCoordinatorLayout(
     // region Configuration observer
 
     private val configObserver =
-        object : StackHeaderConfigurationObserver {
-            override fun onConfigChanged(config: StackHeaderConfigurationProviding) = processUpdate(config)
-
-            override fun onMenuElementsUpdated(updates: List<StackHeaderToolbarMenuElementUpdate>) {
-                val toolbar = appBarLayout?.toolbar
-                if (toolbar == null) {
-                    Log.w(
-                        TAG,
-                        "[RNScreens] Dropping ${updates.size} resolved toolbar menu update(s): " +
-                            "the header toolbar is not currently attached (header hidden or detached).",
-                    )
-                    return
-                }
-                // Apply every element first, collecting the groups whose selection changed,
-                // then emit a single coalesced event per affected group.
-                val affectedGroups = LinkedHashSet<String>()
-                for (update in updates) {
-                    StackHeaderToolbarMenuApplicator.updateToolbarMenuElement(
-                        toolbar,
-                        selectionController.forwardIdMap,
-                        update.id,
-                        update.options,
-                    )
-                    val checked = update.options.checked
-                    if (checked != null) {
-                        selectionController.applyGroupItemStateChange(toolbar, update.id, checked)?.let(affectedGroups::add)
-                    }
-                }
-                affectedGroups.forEach { groupId -> emitGroupSelection(toolbar, groupId) }
-            }
+        StackHeaderConfigurationObserver { flags ->
+            invalidate(flags)
+            flushPendingUpdates()
         }
 
     // endregion
@@ -107,7 +93,8 @@ internal class StackHeaderCoordinatorLayout(
     // region Layout callbacks
 
     private val appBarOffsetListener =
-        AppBarLayout.OnOffsetChangedListener { _, _ ->
+        AppBarLayout.OnOffsetChangedListener { appBar, verticalOffset ->
+            evaluateCollapseState(appBar, verticalOffset)
             onMaybeHeaderLayoutChanged()
         }
 
@@ -133,6 +120,41 @@ internal class StackHeaderCoordinatorLayout(
         StackHeaderFrameSynchronizer.sync(appBar, provider, delegate)
     }
 
+    // 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,
+        verticalOffset: Int,
+    ) {
+        val totalScrollRange = appBar.totalScrollRange
+        isAppBarFullyCollapsed = totalScrollRange > 0 && -verticalOffset >= totalScrollRange
+    }
+
+    // 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
@@ -145,56 +167,81 @@ internal class StackHeaderCoordinatorLayout(
 
     private val applicator = StackHeaderApplicator(wrappedContext)
 
-    private val selectionController = StackHeaderToolbarMenuSelectionController()
-
     private var appBarLayout: StackHeaderAppBarLayout? = null
 
     private val onNavigationIconClick: () -> Unit = {
-        val activity =
-            (stackScreen.context as? ReactContext)?.currentActivity
-                as? OnBackPressedDispatcherOwner
-        activity?.onBackPressedDispatcher?.onBackPressed()
+        backPressHandler.handleHeaderBackButtonPress(stackScreen)
+    }
+
+    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 needsRebuild = provider.invalidationFlags.needsRebuild
+        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 || provider.invalidationFlags.containsAny(StackHeaderInvalidationFlags.TITLE)) {
-                applicator.applyTitle(appBar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.TITLE)
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TITLE)) {
+                applicator.applyTitleAndSubtitle(appBar, provider)
+            }
+
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TITLE_APPEARANCE)) {
+                applicator.applyTitleAndSubtitleAppearance(appBar, provider)
+            }
+
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TITLE_POSITIONING)) {
+                applicator.applyTitlePositioning(appBar, provider)
             }
 
-            if (needsRebuild || provider.invalidationFlags.containsAny(StackHeaderInvalidationFlags.BACK_BUTTON)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.CONTENT_INSETS)) {
+                applicator.applyContentInsets(appBar, provider)
+            }
+
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.BACK_BUTTON)) {
                 applicator.applyBackButton(appBar.toolbar, provider, canNavigateBack, onNavigationIconClick)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.BACK_BUTTON)
             }
 
-            if (needsRebuild || provider.invalidationFlags.containsAny(StackHeaderInvalidationFlags.SCROLL_FLAGS)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.SCROLL_FLAGS)) {
                 applicator.applyScrollFlags(appBar, provider)
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.SCROLL_FLAGS)
             }
 
-            if (needsRebuild || provider.invalidationFlags.containsAny(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)) {
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.BACKGROUND_COLORS)) {
+                applicator.applyBackgroundColors(appBar, provider)
+            }
+
+            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(
@@ -202,61 +249,95 @@ internal class StackHeaderCoordinatorLayout(
                     enabled = provider.liftOnScroll && !provider.transparent,
                     targetScrollView = stackScreen.findContentScrollView(),
                 )
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
             }
 
-            if (provider.invalidationFlags.containsAny(StackHeaderInvalidationFlags.TOOLBAR_MENU)) {
-                val (forwardIdMap, reverseIdMap) =
-                    StackHeaderToolbarMenuApplicator.generateToolbarMenuItemMappings(
-                        provider.toolbarMenu,
-                    )
-                val forwardGroupIdMap =
-                    StackHeaderToolbarMenuApplicator.generateToolbarMenuGroupMappings(
-                        provider.toolbarMenu,
-                    )
-                val groupMetadata =
-                    StackHeaderToolbarMenuApplicator.computeGroupMetadata(
-                        provider.toolbarMenu,
-                    )
-
-                StackHeaderToolbarMenuApplicator.validateRadioInitialSelection(provider.toolbarMenu)
-
-                selectionController.setMenuMaps(forwardIdMap, groupMetadata)
-
-                StackHeaderToolbarMenuApplicator.rebuildToolbarMenu(
-                    appBar.toolbar,
-                    provider.toolbarMenu,
-                    forwardIdMap,
-                    reverseIdMap,
-                    forwardGroupIdMap,
-                    groupDividerEnabled = provider.toolbarMenuGroupDividerEnabled,
-                    onItemClicked = { id, menuItem ->
-                        if (menuItem.isCheckable) {
-                            selectionController.applyGroupItemStateChange(appBar.toolbar, id)?.let { groupId ->
-                                emitGroupSelection(appBar.toolbar, groupId)
-                            }
-                        } else {
-                            currentDelegate?.onMenuItemClicked(id)
-                        }
-                    },
-                )
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.TOOLBAR_MENU)) {
+                provider.toolbarMenuController.attach(appBar.toolbar)
+            }
+
+            if (needsRebuild || flags.containsAny(StackHeaderInvalidationFlags.OVERFLOW_ICON)) {
+                applicator.applyOverflowIcon(appBar.toolbar, provider)
+            }
 
-                provider.clearInvalidationFlags(StackHeaderInvalidationFlags.TOOLBAR_MENU)
+            // 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 Group selection
+    // region Color scheme
 
-    private fun emitGroupSelection(
-        toolbar: MaterialToolbar,
-        groupId: String,
-    ) {
-        currentDelegate?.onGroupSelectionChanged(groupId, selectionController.collectSelectedIds(toolbar, groupId))
+    // 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
+    // redundant full re-applies e.g. on tab switches.
+    private var appliedUiNightMode: Int =
+        context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
+
+    override fun getResolvedUiNightMode() = colorSchemeCoordinator.getResolvedUiNightMode()
+
+    override fun addColorSchemeListener(listener: ColorSchemeListener) = colorSchemeCoordinator.addColorSchemeListener(listener)
+
+    override fun removeColorSchemeListener(listener: ColorSchemeListener) = colorSchemeCoordinator.removeColorSchemeListener(listener)
+
+    // No onConfigurationChanged override is needed: this view never sets its own colorScheme,
+    // so resolution always delegates to the parent provider, which does handle system changes.
+
+    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() {
+        colorSchemeCoordinator.teardown()
+        super.onDetachedFromWindow()
+    }
+
+    private fun applyUiNightMode(uiNightMode: Int) {
+        wrappedContext.setTheme(
+            when (uiNightMode) {
+                Configuration.UI_MODE_NIGHT_YES -> R.style.Theme_Material3Expressive_Dark_NoActionBar
+                Configuration.UI_MODE_NIGHT_NO -> R.style.Theme_Material3Expressive_Light_NoActionBar
+                else -> R.style.Theme_Material3Expressive_DayNight_NoActionBar
+            },
+        )
+
+        if (uiNightMode == appliedUiNightMode) {
+            return
+        }
+
+        appliedUiNightMode = uiNightMode
+        // 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
@@ -269,11 +350,13 @@ internal class StackHeaderCoordinatorLayout(
             removeView(it)
         }
         appBarLayout = null
-        selectionController.clear()
+        currentProvider?.toolbarMenuController?.detach()
     }
 
     private fun removeHeader() {
         resetHeader()
+        isAppBarFullyCollapsed = null
+        builtLayoutDirection = null
         removeContentBehavior()
         requestLayout()
     }
@@ -306,6 +389,22 @@ internal class StackHeaderCoordinatorLayout(
 
     // endregion
 
+    // region Instance state
+
+    override fun dispatchSaveInstanceState(container: SparseArray<Parcelable>) {
+        // Do nothing. This view is the root of a fragment-managed, react-owned hierarchy that
+        // React Native keeps alive, so there is no need to serialize/deserialize native view
+        // state. View ids in this subtree are react tags, which are not stable identities -
+        // restoring state by id can apply state saved by one view type to a different one,
+        // crashing e.g. in CompoundButton (see #4523).
+    }
+
+    override fun dispatchRestoreInstanceState(container: SparseArray<Parcelable>) {
+        // Ignore restoring instance state too, as we are not saving anything anyways.
+    }
+
+    // endregion
+
     // region Init
 
     internal var stackScreenWrapper: FrameLayout
@@ -334,6 +433,9 @@ internal class StackHeaderCoordinatorLayout(
     // region Teardown
 
     internal fun tearDown() {
+        colorSchemeCoordinator.teardown()
+
+        pendingFlags = StackHeaderInvalidationFlags.NONE
         removeHeader()
 
         stackScreenWrapper.removeView(stackScreen)
@@ -346,8 +448,4 @@ internal class StackHeaderCoordinatorLayout(
     }
 
     // endregion
-
-    companion object {
-        private const val TAG = "StackHeaderCoordinatorLayout"
-    }
 }