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

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

@@ -3,6 +3,7 @@ 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
@@ -10,6 +11,7 @@ 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
@@ -17,12 +19,11 @@ import com.swmansion.rnscreens.helpers.resolveImage
 import com.swmansion.rnscreens.stack.header.subview.OnStackHeaderSubviewChangeListener
 import com.swmansion.rnscreens.stack.header.subview.StackHeaderSubview
 import com.swmansion.rnscreens.stack.header.subview.StackHeaderSubviewType
-import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarFieldUpdate
-import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuConfig
-import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuElementRawUpdate
-import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuIconResolver
-import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuItemIconSource
-import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuUpdateQueue
+import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuController
+import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuDelegate
+import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuConfig
+import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMenuElementRawUpdate
+import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMenuIconResolver
 import java.lang.ref.WeakReference
 import kotlin.properties.Delegates
 
@@ -33,6 +34,7 @@ internal class StackHeaderConfig(
 ) : ReactViewGroup(reactContext),
     StackHeaderConfigurationProviding,
     StackHeaderDelegate,
+    StackHeaderToolbarMenuDelegate,
     OnStackHeaderSubviewChangeListener,
     UIManagerListener {
     init {
@@ -71,92 +73,143 @@ internal class StackHeaderConfig(
 
     // region Properties
 
-    override var type: StackHeaderType by Delegates.observable(StackHeaderType.SMALL) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.STRUCTURE)
-    }
+    override var type: StackHeaderType by invalidatingProperty(StackHeaderType.SMALL, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var title: String by Delegates.observable("") { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.TITLE)
-    }
+    override var title: String by invalidatingProperty("", StackHeaderInvalidationFlags.TITLE)
         internal set
 
-    override var hidden: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.STRUCTURE)
-    }
+    override var subtitle: String by invalidatingProperty("", StackHeaderInvalidationFlags.TITLE)
         internal set
 
-    override var transparent: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.STRUCTURE)
-    }
+    // Requires header rebuild due to bug in Material implementation
+    override var maxLines: Int by invalidatingProperty(1, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var backButtonHidden: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var hidden: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var backButtonTintColorNormal: Int? by Delegates.observable(null) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var transparent: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var backButtonTintColorPressed: Int? by Delegates.observable(null) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var backButtonHidden: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var backButtonTintColorFocused: Int? by Delegates.observable(null) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var backButtonTintColorNormal: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var backButtonIcon: Drawable? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var backButtonTintColorPressed: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var scrollFlagScroll: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var backButtonTintColorFocused: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var scrollFlagEnterAlways: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var backButtonIcon: Drawable? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var scrollFlagEnterAlwaysCollapsed: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var overflowIconTintColorNormal: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var scrollFlagExitUntilCollapsed: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var overflowIconTintColorPressed: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var scrollFlagSnap: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var overflowIconTintColorFocused: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var toolbarMenu: StackHeaderToolbarMenuConfig
-        by Delegates.observable(StackHeaderToolbarMenuConfig(emptyList(), emptyList())) { _, old, new ->
-            if (old != new) invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
-        }
+    override var overflowIcon: Drawable? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var toolbarMenuGroupDividerEnabled: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
-    }
+    override var scrollFlagScroll: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
         internal set
 
+    override var scrollFlagEnterAlways: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var scrollFlagEnterAlwaysCollapsed: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var scrollFlagExitUntilCollapsed: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var scrollFlagSnap: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var liftOnScroll: Boolean by invalidatingProperty(true, StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
+        internal set
+
+    override var backgroundColor: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACKGROUND_COLORS)
+        internal set
+
+    override var scrolledBackgroundColor: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACKGROUND_COLORS)
+        internal set
+
+    override var statusBarScrimColor: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACKGROUND_COLORS)
+        internal set
+
+    override var titleCentered: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var subtitleCentered: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var expandedTitleHorizontalGravity: Int by invalidatingProperty(Gravity.START, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var expandedTitleVerticalGravity: Int by invalidatingProperty(Gravity.BOTTOM, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var collapsedTitleHorizontalGravity: Int by invalidatingProperty(Gravity.START, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var collapsedTitleVerticalGravity: Int by invalidatingProperty(
+        Gravity.CENTER_VERTICAL,
+        StackHeaderInvalidationFlags.TITLE_POSITIONING,
+    )
+        internal set
+
+    override var collapsedTitleGravityMode: StackHeaderCollapsedTitleGravityMode
+        by invalidatingProperty(StackHeaderCollapsedTitleGravityMode.AVAILABLE_SPACE, StackHeaderInvalidationFlags.STRUCTURE)
+        internal set
+
+    override var contentInsetStart: Float?
+        by invalidatingProperty(null, StackHeaderInvalidationFlags.CONTENT_INSETS)
+        internal set
+
+    override var contentInsetEnd: Float?
+        by invalidatingProperty(null, StackHeaderInvalidationFlags.CONTENT_INSETS)
+        internal set
+
+    override val titleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val subtitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val expandedTitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val collapsedTitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val expandedSubtitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val collapsedSubtitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+
+    private fun invalidateTextAppearance() = invalidate(StackHeaderInvalidationFlags.TITLE_APPEARANCE)
+
     override val isRTL: Boolean
         get() = layoutDirection == LayoutDirection.RTL
 
     // endregion
 
+    // region Content scroll view
+
+    /**
+     * Called by the owning [com.swmansion.rnscreens.stack.screen.StackScreen]
+     * when its content scroll view changes (e.g. a `ScrollViewMarker` registered
+     * one). Re-triggers lift-on-scroll so the coordinator can resolve and apply
+     * the up-to-date `liftOnScrollTargetView`.
+     */
+    internal fun onContentScrollViewChanged() {
+        invalidate(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
+        if (!isInsideMountTransaction) {
+            flushUpdates()
+        }
+    }
+
+    // endregion
+
     // region Back button icon resolution
 
     // Staging fields for back button icon resolution.
@@ -164,11 +217,10 @@ internal class StackHeaderConfig(
     // Resolution happens in resolveBackButtonIconIfNeeded(), called from onAfterUpdateTransaction.
     internal var backButtonDrawableIconResourceName: String? = null
     internal var backButtonImageIconUri: String? = null
-    private val backButtonIconResolver = PropIconResolver()
+    private val backButtonIconResolver = createPropIconResolver(reactContext)
 
     internal fun resolveBackButtonIconIfNeeded() {
         backButtonIconResolver.resolve(
-            reactContext,
             backButtonDrawableIconResourceName,
             backButtonImageIconUri,
         ) { result ->
@@ -186,82 +238,82 @@ internal class StackHeaderConfig(
 
     // endregion
 
-    // region Toolbar menu item icon resolution
+    // region Overflow menu icon resolution
 
-    internal var toolbarMenuItemIconSourceMap = mapOf<String, StackHeaderToolbarMenuItemIconSource>()
+    // Staging fields for overflow menu icon resolution — mirrors the back button icon.
+    // Resolution happens in resolveOverflowIconIfNeeded(), called from onAfterUpdateTransaction.
+    internal var overflowIconDrawableIconResourceName: String? = null
+    internal var overflowIconImageIconUri: String? = null
+    private val overflowIconResolver = createPropIconResolver(reactContext)
 
-    private var toolbarMenuItemIconResolvers = mapOf<String, PropIconResolver>()
+    internal fun resolveOverflowIconIfNeeded() {
+        overflowIconResolver.resolve(
+            overflowIconDrawableIconResourceName,
+            overflowIconImageIconUri,
+        ) { result ->
+            when (result) {
+                IconResolution.Unchanged -> Unit
+                is IconResolution.Resolved -> {
+                    overflowIcon = result.drawable
+                    if (!isInsideMountTransaction) {
+                        flushUpdates()
+                    }
+                }
+            }
+        }
+    }
 
-    // Last resolved icon per menu item id, from the `toolbarMenu` prop path only
-    // (resolveToolbarMenuItemIconsIfNeeded). Command (`updateToolbarMenuElements`) icons are applied
-    // directly to the live toolbar and are intentionally NOT stored here.
-    private var toolbarMenuItemIcons = mapOf<String, Drawable?>()
+    // endregion
 
-    internal fun resolveToolbarMenuItemIconsIfNeeded() {
-        val nextResolvers = mutableMapOf<String, PropIconResolver>()
+    // region Toolbar menu
 
-        toolbarMenuItemIconSourceMap.forEach { (id, source) ->
-            val resolver = toolbarMenuItemIconResolvers[id] ?: PropIconResolver()
-            nextResolvers[id] = resolver
+    override val toolbarMenuController =
+        StackHeaderToolbarMenuController(createMenuIconResolver(reactContext))
+            .also { it.delegate = WeakReference(this) }
 
-            resolver.resolve(
-                context = reactContext,
-                drawableIconResourceName = source.drawableIconResourceName,
-                imageIconUri = source.imageIconUri,
-            ) { result ->
-                val icon =
-                    when (result) {
-                        IconResolution.Unchanged -> toolbarMenuItemIcons[id]
-                        is IconResolution.Resolved -> {
-                            toolbarMenuItemIcons = toolbarMenuItemIcons + (id to result.drawable)
-                            result.drawable
-                        }
-                    }
+    internal fun setToolbarMenuFromProps(menu: StackHeaderToolbarMenuConfig) {
+        if (toolbarMenuController.setMenu(menu)) {
+            invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
+        }
+    }
 
-                applyToolbarMenuItemIcon(id, icon)
-            }
+    internal fun setToolbarMenuGroupDividerEnabledFromProps(enabled: Boolean) {
+        if (toolbarMenuController.setGroupDividerEnabled(enabled)) {
+            invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
         }
+    }
+
+    internal fun dispatchMenuElementUpdates(updates: List<StackHeaderToolbarMenuElementRawUpdate>) {
+        toolbarMenuController.enqueueElementUpdates(updates)
+    }
+
+    // StackHeaderToolbarMenuDelegate -> JS events
 
-        toolbarMenuItemIconResolvers = nextResolvers
-        toolbarMenuItemIcons = toolbarMenuItemIcons.filterKeys { it in toolbarMenuItemIconSourceMap }
+    override fun onMenuItemClicked(id: String) {
+        eventEmitter.emitOnToolbarMenuItemPress(id)
     }
 
-    private fun applyToolbarMenuItemIcon(
-        id: String,
-        icon: Drawable?,
+    override fun onGroupSelectionChanged(
+        groupId: String,
+        selectedIds: List<String>,
     ) {
-        val currentMenu = toolbarMenu
-        val updated = currentMenu.updateItemIcon(id, icon)
-        if (updated !== currentMenu) {
-            toolbarMenu = updated
-            if (!isInsideMountTransaction) {
-                flushUpdates()
-            }
-        }
+        eventEmitter.emitOnToolbarMenuGroupSelectionChange(groupId, selectedIds)
     }
 
     // endregion
 
     // region Subviews
 
-    override var backgroundSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var backgroundSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
-    override var leadingSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var leadingSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
-    override var centerSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var centerSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
-    override var trailingSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var trailingSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
     override fun onStackHeaderSubviewChanged() {
@@ -327,17 +379,6 @@ internal class StackHeaderConfig(
         )
     }
 
-    override fun onMenuItemClicked(id: String) {
-        eventEmitter.emitOnToolbarMenuItemPress(id)
-    }
-
-    override fun onGroupSelectionChanged(
-        groupId: String,
-        selectedIds: List<String>,
-    ) {
-        eventEmitter.emitOnToolbarMenuGroupSelectionChange(groupId, selectedIds)
-    }
-
     override fun onSubviewOriginChanged(
         type: StackHeaderSubviewType,
         x: Int,
@@ -366,52 +407,6 @@ internal class StackHeaderConfig(
 
     // endregion
 
-    // region Imperative menu item commands
-
-    /**
-     * Resolves a single command's icon. Unlike the `toolbarMenu` prop path,
-     * this does NOT go through the stateful per-id [PropIconResolver] (whose
-     * drop-stale async guard could leave the queue waiting forever - the queue
-     * requires that [StackHeaderToolbarMenuIconResolver.resolve] always calls
-     * [onResolved] even if the image loading results in failure; see
-     * [StackHeaderToolbarMenuIconResolver] and
-     * [StackHeaderToolbarMenuUpdateQueue] for more details) and does NOT touch
-     * the prop icon cache: it resolves the source with an always-completing
-     * [resolveImage] and forwards the result to the queue, which applies it to
-     * the live toolbar. Ordering across commands is guaranteed by the queue, so
-     * no drop-stale is needed here; a failed or empty source resolves to `null`
-     * -> Reset (the icon is cleared) rather than stalling the queue.
-     */
-    private val commandIconResolver =
-        StackHeaderToolbarMenuIconResolver { iconSource, onResolved ->
-            resolveImage(
-                reactContext,
-                iconSource.drawableIconResourceName,
-                iconSource.imageIconUri,
-            ) { drawable ->
-                onResolved(StackHeaderToolbarFieldUpdate.from(drawable))
-            }
-        }
-
-    // Serializes `updateToolbarMenuElements` batches and waits for every icon in a batch to
-    // resolve before applying it, so each batch is applied atomically and in order.
-    private val menuUpdateQueue =
-        StackHeaderToolbarMenuUpdateQueue(
-            iconResolver = commandIconResolver,
-            delegate = { updates -> configObserver?.onMenuElementsUpdated(updates) },
-        )
-
-    /**
-     * Enqueues a batch of toolbar menu element view commands. The batch is processed only
-     * after any earlier batch has been fully applied, and is applied atomically once all of
-     * its icons (if any) have resolved — see [StackHeaderToolbarMenuUpdateQueue].
-     */
-    internal fun dispatchMenuElementUpdates(updates: List<StackHeaderToolbarMenuElementRawUpdate>) {
-        menuUpdateQueue.enqueue(updates)
-    }
-
-    // endregion
-
     // region UIManagerListener
 
     private var isInsideMountTransaction = false
@@ -439,10 +434,40 @@ internal class StackHeaderConfig(
         UIManagerHelper
             .getFabricUIManagerNotNull(reactContext)
             .removeUIManagerEventListener(this)
-        menuUpdateQueue.tearDown()
+        toolbarMenuController.tearDown()
         invalidationFlags = StackHeaderInvalidationFlags.NONE
         configObserver = null
     }
 
     // endregion
+
+    // region Helpers
+
+    private fun <T> invalidatingProperty(
+        initialValue: T,
+        flag: StackHeaderInvalidationFlags,
+    ) = Delegates.observable(initialValue) { _, old, new ->
+        if (old != new) invalidate(flag)
+    }
+
+    // endregion
+
+    // Built outside the instance scope on purpose: a lambda capturing this view
+    // would be retained by every icon load still in flight.
+    private companion object {
+        fun createPropIconResolver(context: ThemedReactContext) =
+            PropIconResolver { name, uri, onComplete ->
+                resolveImage(context, name, uri, onComplete)
+            }
+
+        fun createMenuIconResolver(context: ThemedReactContext) =
+            StackHeaderToolbarMenuIconResolver { iconSource, onResolved ->
+                resolveImage(
+                    context,
+                    iconSource.drawableIconResourceName,
+                    iconSource.imageIconUri,
+                    onResolved,
+                )
+            }
+    }
 }