Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b40cb9b3 authored by Treehugger Robot's avatar Treehugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic "catalyst" into main

* changes:
  [Catalyst] Do not dump isPersistent for PreferenceGroup
  [Catalyst] Add remove/onGroup for PreferenceHierarchy
  [Catalyst] Enhance PreferenceBindingPlaceholder support
parents 614c5254 7ab27323
Loading
Loading
Loading
Loading
+20 −10
Original line number Diff line number Diff line
@@ -57,6 +57,12 @@ internal constructor(private val context: Context, metadata: PreferenceMetadata)
     */
    operator fun String.unaryPlus() = addPreferenceScreen(this, null)

    /** Removes preference with given key from the hierarchy. */
    operator fun String.unaryMinus() {
        val (hierarchy, index) = findPreference(this) ?: return
        hierarchy.children.removeAt(index)
    }

    /**
     * Adds parameterized preference screen with given key (as a placeholder) to the hierarchy.
     *
@@ -83,31 +89,35 @@ internal constructor(private val context: Context, metadata: PreferenceMetadata)

    /** Adds a preference to the hierarchy before given key. */
    fun addBefore(key: String, metadata: PreferenceMetadata) {
        val (list, index) = findPreference(key) ?: (children to children.size)
        list.add(index, PreferenceHierarchyNode(metadata))
        val (hierarchy, index) = findPreference(key) ?: (this to children.size)
        hierarchy.children.add(index, PreferenceHierarchyNode(metadata))
    }

    /** Adds a preference group to the hierarchy before given key. */
    fun addGroupBefore(key: String, metadata: PreferenceMetadata): PreferenceHierarchy {
        val (list, index) = findPreference(key) ?: (children to children.size)
        return PreferenceHierarchy(context, metadata).also { list.add(index, it) }
        val (hierarchy, index) = findPreference(key) ?: (this to children.size)
        return PreferenceHierarchy(context, metadata).also { hierarchy.children.add(index, it) }
    }

    /** Adds a preference to the hierarchy after given key. */
    fun addAfter(key: String, metadata: PreferenceMetadata) {
        val (list, index) = findPreference(key) ?: (children to children.size - 1)
        list.add(index + 1, PreferenceHierarchyNode(metadata))
        val (hierarchy, index) = findPreference(key) ?: (this to children.size - 1)
        hierarchy.children.add(index + 1, PreferenceHierarchyNode(metadata))
    }

    /** Adds a preference group to the hierarchy after given key. */
    fun addGroupAfter(key: String, metadata: PreferenceMetadata): PreferenceHierarchy {
        val (list, index) = findPreference(key) ?: (children to children.size - 1)
        return PreferenceHierarchy(context, metadata).also { list.add(index + 1, it) }
        val (hierarchy, index) = findPreference(key) ?: (this to children.size - 1)
        return PreferenceHierarchy(context, metadata).also { hierarchy.children.add(index + 1, it) }
    }

    private fun findPreference(key: String): Pair<MutableList<PreferenceHierarchyNode>, Int>? {
    /** Manipulates hierarchy on a preference group with given key. */
    fun onGroup(key: String, init: PreferenceHierarchy.() -> Unit) =
        findPreference(key)!!.apply { init(first.children[second] as PreferenceHierarchy) }

    private fun findPreference(key: String): Pair<PreferenceHierarchy, Int>? {
        children.forEachIndexed { index, node ->
            if (node.metadata.key == key) return children to index
            if (node.metadata.key == key) return this to index
            if (node is PreferenceHierarchy) {
                val result = node.findPreference(key)
                if (result != null) return result
+21 −23
Original line number Diff line number Diff line
@@ -265,8 +265,6 @@ class PreferenceScreenBindingHelper(
            preferenceHierarchy: PreferenceHierarchy,
        ) {
            val preferenceScreenMetadata = preferenceHierarchy.metadata as PreferenceScreenMetadata
            val preferences = mutableMapOf<String, PreferenceHierarchyNode>()
            preferenceHierarchy.forEachRecursively { preferences[it.metadata.key] = it }
            val storages = mutableMapOf<KeyValueStore, PreferenceDataStore>()

            fun Preference.setPreferenceDataStore(metadata: PreferenceMetadata) {
@@ -278,32 +276,32 @@ class PreferenceScreenBindingHelper(
                }
            }

            fun PreferenceGroup.bindRecursively() {
                preferences.remove(key)?.let { preferenceBindingFactory.bind(this, it) }
                val count = preferenceCount
                for (index in 0 until count) {
                    val preference = getPreference(index)
                    if (preference is PreferenceGroup) {
                        preference.bindRecursively()
            fun PreferenceHierarchy.bindRecursively(preferenceGroup: PreferenceGroup) {
                preferenceBindingFactory.bind(preferenceGroup, this)
                val preferences = mutableMapOf<String, PreferenceHierarchyNode>()
                forEach { preferences[it.metadata.key] = it }
                for (index in 0 until preferenceGroup.preferenceCount) {
                    val preference = preferenceGroup.getPreference(index)
                    val node = preferences.remove(preference.key) ?: continue
                    if (node is PreferenceHierarchy) {
                        node.bindRecursively(preference as PreferenceGroup)
                    } else {
                        preferences.remove(preference.key)?.let {
                            preference.setPreferenceDataStore(it.metadata)
                            preferenceBindingFactory.bind(preference, it)
                        }
                    }
                        preference.setPreferenceDataStore(node.metadata)
                        preferenceBindingFactory.bind(preference, node)
                    }
                }

            preferenceScreen.bindRecursively()
                for (node in preferences.values) {
                    val metadata = node.metadata
                    val binding = preferenceBindingFactory.getPreferenceBinding(metadata)
                    if (binding !is PreferenceBindingPlaceholder) continue
                val preference = binding.createWidget(preferenceScreen.context)
                    val preference = binding.createWidget(preferenceGroup.context)
                    preference.setPreferenceDataStore(metadata)
                    preferenceBindingFactory.bind(preference, node, binding)
                preferenceScreen.addPreference(preference)
                    preferenceGroup.addPreference(preference)
                }
            }

            preferenceHierarchy.bindRecursively(preferenceScreen)
        }
    }
}
+3 −1
Original line number Diff line number Diff line
@@ -128,7 +128,9 @@ abstract class CatalystScreenTestCase {
        builder.append(indent2).append("isCopyingEnabled: $isCopyingEnabled\n")
        builder.append(indent2).append("isEnabled: $isEnabled\n")
        builder.append(indent2).append("isIconSpaceReserved: $isIconSpaceReserved\n")
        if (clazz != Preference::class.java && clazz != PreferenceScreen::class.java) {
        if (
            clazz != Preference::class.java && !PreferenceGroup::class.java.isAssignableFrom(clazz)
        ) {
            builder.append(indent2).append("isPersistent: $isPersistent\n")
        }
        builder.append(indent2).append("isSelectable: $isSelectable\n")