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

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

@@ -12,176 +12,32 @@ import com.swmansion.rnscreens.stack.header.getResizedDrawable
 import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuConfig
 import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuElementConfig
 import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuGroupConfig
-import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuGroupMetadata
-import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuItemConfig
-import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuItemType
+import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuModel
 import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarFieldUpdate
 import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMenuElementOptions
 import com.swmansion.rnscreens.stack.header.toolbar.update.valueOrNull
 
 /**
- * Builds the toolbar menu from its config and applies in-place element updates
- * (options, checkability, icon tint).
+ * Writes onto the android Menu: builds the toolbar menu from its model and
+ * applies in-place element updates (options, checkability, icon tint).
  */
 internal object StackHeaderToolbarMenuApplicator {
-    // region Mappings & metadata
-
-    internal fun generateToolbarMenuItemMappings(menuConfig: StackHeaderToolbarMenuConfig): Pair<Map<String, Int>, Map<Int, String>> {
-        val forwardIdMap = mutableMapOf<String, Int>()
-        val reverseIdMap = mutableMapOf<Int, String>()
-        var counter = 1
-        assignElementIds(menuConfig.children, forwardIdMap, reverseIdMap) { counter++ }
-        return Pair(forwardIdMap.toMap(), reverseIdMap.toMap())
-    }
-
-    internal fun generateToolbarMenuGroupMappings(menuConfig: StackHeaderToolbarMenuConfig): Map<String, Int> {
-        val forwardGroupIdMap = mutableMapOf<String, Int>()
-        var counter = 1
-        assignGroupIds(menuConfig, forwardGroupIdMap) { counter++ }
-        return forwardGroupIdMap.toMap()
-    }
-
-    internal fun computeGroupMetadata(menuConfig: StackHeaderToolbarMenuConfig): StackHeaderToolbarMenuGroupMetadata {
-        val itemGroupMap = mutableMapOf<String, String>()
-        val groupSingleSelection = mutableMapOf<String, Boolean>()
-        val groupMemberItems = mutableMapOf<String, MutableList<String>>()
-        collectGroupMetadata(menuConfig, itemGroupMap, groupSingleSelection, groupMemberItems)
-        return StackHeaderToolbarMenuGroupMetadata(
-            itemGroupMap,
-            groupSingleSelection,
-            groupMemberItems.mapValues { it.value.toList() },
-        )
-    }
-
-    internal fun validateRadioInitialSelection(menuConfig: StackHeaderToolbarMenuConfig) {
-        for (group in menuConfig.groups) {
-            if (!group.singleSelection) continue
-            var count = 0
-            for (element in menuConfig.children) {
-                if (element.item.groupId == group.groupId && element.item.initialToggleState) {
-                    count++
-                }
-            }
-            require(count <= 1) {
-                "[RNScreens] Radio group '${group.groupId}' has $count items with " +
-                    "initialToggleState=true. At most 1 is allowed for single-selection groups."
-            }
-        }
-        for (element in menuConfig.children) {
-            if (element is StackHeaderToolbarMenuElementConfig.Submenu) {
-                validateRadioInitialSelection(element.menu)
-            }
-        }
-    }
-
-    /**
-     * Recursively traverses menu elements and maps user-friendly string item IDs to integers
-     * expected by Android.
-     *
-     * @param elements List of menu elements.
-     * @param forwardIdMap Reference to String->Int ID map to which ID entries will be added.
-     * @param reverseIdMap Reference to Int->String ID map to which ID entries will be added.
-     * @param nextId Function that returns next ID integer. New unique integer should be returned
-     *               each time the function is called. The function is used to handle recursive
-     *               element traversal.
-     */
-    private fun assignElementIds(
-        elements: List<StackHeaderToolbarMenuElementConfig>,
-        forwardIdMap: MutableMap<String, Int>,
-        reverseIdMap: MutableMap<Int, String>,
-        nextId: () -> Int,
-    ) {
-        for (element in elements) {
-            require(element.item.id !in forwardIdMap) {
-                "[RNScreens] Duplicate toolbar menu item id: '${element.item.id}'. Item IDs must be unique across the entire menu."
-            }
-            val nativeId = nextId()
-            forwardIdMap[element.item.id] = nativeId
-            reverseIdMap[nativeId] = element.item.id
-            if (element is StackHeaderToolbarMenuElementConfig.Submenu) {
-                assignElementIds(element.menu.children, forwardIdMap, reverseIdMap, nextId)
-            }
-        }
-    }
-
-    /**
-     * Recursively traverses menu groups and maps user-friendly string group IDs to integers
-     * expected by Android.
-     *
-     * @param menuConfig Menu whose groups — and those of its submenus — will be mapped.
-     * @param forwardMap Reference to String->Int group ID map to which entries will be added.
-     * @param nextId Function that returns next ID integer. New unique integer should be returned
-     *               each time the function is called. The function is used to handle recursive
-     *               element traversal.
-     */
-    private fun assignGroupIds(
-        menuConfig: StackHeaderToolbarMenuConfig,
-        forwardMap: MutableMap<String, Int>,
-        nextId: () -> Int,
-    ) {
-        for (group in menuConfig.groups) {
-            require(group.groupId !in forwardMap) {
-                "[RNScreens] Duplicate toolbar menu group id: '${group.groupId}'. Group IDs must be unique across the entire menu."
-            }
-            forwardMap[group.groupId] = nextId()
-        }
-        for (element in menuConfig.children) {
-            if (element is StackHeaderToolbarMenuElementConfig.Submenu) {
-                assignGroupIds(element.menu, forwardMap, nextId)
-            }
-        }
-    }
-
-    private fun collectGroupMetadata(
-        config: StackHeaderToolbarMenuConfig,
-        itemGroupMap: MutableMap<String, String>,
-        groupSingleSelection: MutableMap<String, Boolean>,
-        groupMemberItems: MutableMap<String, MutableList<String>>,
-    ) {
-        val localGroupIds = config.groups.map { it.groupId }.toSet()
-        for (group in config.groups) {
-            groupSingleSelection[group.groupId] = group.singleSelection
-            groupMemberItems.getOrPut(group.groupId) { mutableListOf() }
-        }
-        for (element in config.children) {
-            element.item.groupId?.let { gid ->
-                require(gid in localGroupIds) {
-                    "[RNScreens] Menu item '${element.item.id}' references group '$gid' " +
-                        "which is not defined at the same menu level. " +
-                        "Groups cannot span submenus."
-                }
-                itemGroupMap[element.item.id] = gid
-                groupMemberItems[gid]!!.add(element.item.id)
-            }
-            if (element is StackHeaderToolbarMenuElementConfig.Submenu) {
-                collectGroupMetadata(element.menu, itemGroupMap, groupSingleSelection, groupMemberItems)
-            }
-        }
-    }
-
-    // endregion
-
     // region Menu build
 
     internal fun rebuildToolbarMenu(
         toolbar: MaterialToolbar,
-        menuConfig: StackHeaderToolbarMenuConfig,
-        forwardIdMap: Map<String, Int>,
-        reverseIdMap: Map<Int, String>,
-        forwardGroupIdMap: Map<String, Int>,
+        model: StackHeaderToolbarMenuModel,
         groupDividerEnabled: Boolean,
-        onItemClicked: (id: String, menuItem: MenuItem) -> Unit,
+        optionsForItem: (id: String) -> StackHeaderToolbarMenuElementOptions,
+        onItemClicked: (id: String) -> Unit,
     ) {
         toolbar.menu.clear()
-        addElements(toolbar, toolbar.menu, menuConfig, forwardIdMap, forwardGroupIdMap)
+        addElements(toolbar, toolbar.menu, model.config, model.forwardIdMap, model.forwardGroupIdMap, optionsForItem)
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
             toolbar.menu.setGroupDividerEnabled(groupDividerEnabled)
         }
         toolbar.setOnMenuItemClickListener { menuItem ->
-            val stringId = reverseIdMap[menuItem.itemId]
-            if (stringId != null) {
-                onItemClicked(stringId, menuItem)
-            }
+            model.reverseIdMap[menuItem.itemId]?.let(onItemClicked)
             true
         }
     }
@@ -192,6 +48,7 @@ internal object StackHeaderToolbarMenuApplicator {
         menuConfig: StackHeaderToolbarMenuConfig,
         forwardIdMap: Map<String, Int>,
         forwardGroupIdMap: Map<String, Int>,
+        optionsForItem: (id: String) -> StackHeaderToolbarMenuElementOptions,
     ) {
         menuConfig.children.forEachIndexed { index, element ->
             val itemId =
@@ -205,20 +62,21 @@ internal object StackHeaderToolbarMenuApplicator {
             when (element) {
                 is StackHeaderToolbarMenuElementConfig.MenuItem -> {
                     val menuItem = menu.add(groupIntId, itemId, index, null)
-                    applyMenuElementOptions(toolbar, menuItem, element.item.toOptions())
-                    applyCheckability(menuItem, element.item)
+                    applyMenuElementOptions(toolbar, menuItem, optionsForItem(element.item.id))
                 }
                 is StackHeaderToolbarMenuElementConfig.Submenu -> {
                     val subMenu = menu.addSubMenu(groupIntId, itemId, index, null)
-                    applyMenuElementOptions(toolbar, subMenu.item, element.item.toOptions())
-                    element.menuTitle?.let { subMenu.setHeaderTitle(it) }
-                    addElements(toolbar, subMenu, element.menu, forwardIdMap, forwardGroupIdMap)
+                    applyMenuElementOptions(toolbar, subMenu.item, optionsForItem(element.item.id))
+                    addElements(toolbar, subMenu, element.menu, forwardIdMap, forwardGroupIdMap, optionsForItem)
                 }
             }
         }
         configureGroupCheckability(menu, menuConfig.groups, forwardGroupIdMap)
     }
 
+    // Group membership is the only source of checkability (configs are validated
+    // up front, see StackHeaderToolbarMenuModel); checked state belongs to the
+    // controller, which projects it right after the rebuild.
     private fun configureGroupCheckability(
         menu: Menu,
         groups: List<StackHeaderToolbarMenuGroupConfig>,
@@ -230,34 +88,6 @@ internal object StackHeaderToolbarMenuApplicator {
         }
     }
 
-    private fun applyCheckability(
-        menuItem: MenuItem,
-        itemConfig: StackHeaderToolbarMenuItemConfig,
-    ) {
-        val shouldBeCheckable =
-            when (itemConfig.itemType) {
-                StackHeaderToolbarMenuItemType.TOGGLE -> {
-                    require(itemConfig.groupId != null) {
-                        "[RNScreens] Menu item '${itemConfig.id}' has itemType=TOGGLE but no groupId. " +
-                            "Toggle items must belong to a group."
-                    }
-                    true
-                }
-                StackHeaderToolbarMenuItemType.AUTOMATIC -> itemConfig.groupId != null
-                StackHeaderToolbarMenuItemType.ACTION -> {
-                    require(itemConfig.groupId == null) {
-                        "[RNScreens] Menu item '${itemConfig.id}' has itemType=ACTION " +
-                            "and belongs to a group. Action items cannot belong to groups."
-                    }
-                    false
-                }
-            }
-        if (shouldBeCheckable) {
-            menuItem.isCheckable = true
-            menuItem.isChecked = itemConfig.initialToggleState
-        }
-    }
-
     // endregion
 
     // region Element updates
@@ -291,11 +121,6 @@ internal object StackHeaderToolbarMenuApplicator {
         }
         options.hidden?.let { menuItem.isVisible = !it }
         options.disabled?.let { menuItem.isEnabled = !it }
-        options.showAsAction?.let { menuItem.setShowAsAction(it.toNativeShowAsAction()) }
-
-        // checked is intentionally not handled here. The coordinator layout manages it in
-        // applyGroupItemStateChange because toggling checked state requires group metadata
-        // (radio vs checkbox) and may emit onGroupSelectionChanged events.
 
         options.icon?.let {
             when (it) {
@@ -305,8 +130,11 @@ internal object StackHeaderToolbarMenuApplicator {
             }
         }
 
+        // The tint list is built absolutely from the given fields, so whenever
+        // this branch runs the caller must pass all four tint slots resolved
+        // (Set/Reset) — see StackHeaderToolbarMenuController.effectiveOptions.
         if (options.requiresIconTintColorUpdate || options.icon != null) {
-            MenuItemCompat.setIconTintList(menuItem, getResolvedIconTintList(menuItem, options))
+            MenuItemCompat.setIconTintList(menuItem, buildIconTintList(options))
         }
 
         options.menuTitle?.let { update ->
@@ -321,95 +149,35 @@ internal object StackHeaderToolbarMenuApplicator {
                 Log.w(TAG, "[RNScreens] menuTitle ignored: target is not a submenu.")
             }
         }
-    }
 
-    private fun StackHeaderToolbarMenuItemConfig.toOptions() =
-        StackHeaderToolbarMenuElementOptions(
-            title = StackHeaderToolbarFieldUpdate.from(title),
-            titleCondensed = StackHeaderToolbarFieldUpdate.from(titleCondensed),
-            tooltipText = StackHeaderToolbarFieldUpdate.from(tooltipText),
-            accessibilityLabel = StackHeaderToolbarFieldUpdate.from(accessibilityLabel),
-            hidden = hidden,
-            disabled = disabled,
-            showAsAction = showAsAction,
-            icon = StackHeaderToolbarFieldUpdate.from(icon),
-            iconTintColorNormal = StackHeaderToolbarFieldUpdate.from(iconTintColorNormal),
-            iconTintColorPressed = StackHeaderToolbarFieldUpdate.from(iconTintColorPressed),
-            iconTintColorFocused = StackHeaderToolbarFieldUpdate.from(iconTintColorFocused),
-            iconTintColorDisabled = StackHeaderToolbarFieldUpdate.from(iconTintColorDisabled),
-        )
+        // Apply showAsAction property after icon is set to ensure correct overflow behavior.
+        options.showAsAction?.let { menuItem.setShowAsAction(it.toNativeShowAsAction()) }
+    }
 
     // endregion
 
     // region Icon tint
 
-    private fun getResolvedIconTintList(
-        menuItem: MenuItem,
-        options: StackHeaderToolbarMenuElementOptions,
-    ): ColorStateList? {
-        val currentTintList = MenuItemCompat.getIconTintList(menuItem)
-        // The currently-applied normal (catch-all) color, if any. Used both as the "leave
-        // unchanged" value for normal and to dedup read-back overrides: when a normal entry
-        // exists every override probe also matches it, so an override equal to the current
-        // normal is the catch-all leaking through rather than an explicit override.
-        val currentNormal = currentTintList?.resolvedColorOrNull(intArrayOf(android.R.attr.state_enabled))
-
-        val finalNormal =
-            when (val update = options.iconTintColorNormal) {
-                StackHeaderToolbarFieldUpdate.Reset -> null
-                is StackHeaderToolbarFieldUpdate.Set -> update.value
-                null -> currentNormal
-            }
-
-        val finalDisabled =
-            when (val update = options.iconTintColorDisabled) {
-                StackHeaderToolbarFieldUpdate.Reset -> null
-                is StackHeaderToolbarFieldUpdate.Set -> update.value
-                null ->
-                    currentTintList
-                        ?.resolvedColorOrNull(intArrayOf(-android.R.attr.state_enabled))
-                        ?.takeIf { it != currentNormal }
-            }
-
-        val finalPressed =
-            when (val update = options.iconTintColorPressed) {
-                StackHeaderToolbarFieldUpdate.Reset -> null
-                is StackHeaderToolbarFieldUpdate.Set -> update.value
-                null ->
-                    currentTintList
-                        ?.resolvedColorOrNull(intArrayOf(android.R.attr.state_enabled, android.R.attr.state_pressed))
-                        ?.takeIf { it != currentNormal }
-            }
-
-        val finalFocused =
-            when (val update = options.iconTintColorFocused) {
-                StackHeaderToolbarFieldUpdate.Reset -> null
-                is StackHeaderToolbarFieldUpdate.Set -> update.value
-                null ->
-                    currentTintList
-                        ?.resolvedColorOrNull(intArrayOf(android.R.attr.state_enabled, android.R.attr.state_focused))
-                        ?.takeIf { it != currentNormal }
-            }
-
+    private fun buildIconTintList(options: StackHeaderToolbarMenuElementOptions): ColorStateList? {
         val states = mutableListOf<IntArray>()
         val colors = mutableListOf<Int>()
 
-        finalDisabled?.let {
+        options.iconTintColorDisabled?.valueOrNull()?.let {
             states.add(intArrayOf(-android.R.attr.state_enabled))
             colors.add(it)
         }
 
-        finalPressed?.let {
+        options.iconTintColorPressed?.valueOrNull()?.let {
             states.add(intArrayOf(android.R.attr.state_pressed))
             colors.add(it)
         }
 
-        finalFocused?.let {
+        options.iconTintColorFocused?.valueOrNull()?.let {
             states.add(intArrayOf(android.R.attr.state_focused))
             colors.add(it)
         }
 
-        finalNormal?.let {
+        options.iconTintColorNormal?.valueOrNull()?.let {
             states.add(intArrayOf())
             colors.add(it)
         }
@@ -421,28 +189,7 @@ internal object StackHeaderToolbarMenuApplicator {
         }
     }
 
-    /**
-     * Resolves the color the receiver applies to [stateSet], or `null` when no state spec
-     * matches it.
-     *
-     * `getColorForState` returns the caller-supplied fallback when nothing matches, so we
-     * probe twice with two distinct sentinels: equal results mean a real spec matched (the
-     * actual color), differing results mean the slot is absent. This is robust for any color
-     * value and keeps the read-back stateless — see [getResolvedIconTintList].
-     */
-    private fun ColorStateList.resolvedColorOrNull(stateSet: IntArray): Int? {
-        val a = getColorForState(stateSet, SENTINEL_A)
-        val b = getColorForState(stateSet, SENTINEL_B)
-        return if (a == b) a else null
-    }
-
     // endregion
 
     private const val TAG = "StackHeaderToolbarMenuApplicator"
-
-    // Two distinct sentinel fallbacks used to detect whether a ColorStateList actually
-    // defines a color for a given state. Their concrete values are irrelevant as long as
-    // they differ — see resolvedColorOrNull.
-    private const val SENTINEL_A = 0x00000001
-    private const val SENTINEL_B = 0x00000002
 }