#1223 feature: sorting key maps

app/src/main/java/io/github/sds100/keymapper/UseCases.kt

@@ -23,6 +23,11 @@ import io.github.sds100.keymapper.mappings.keymaps.detection.DetectKeyMapsUseCas
 import io.github.sds100.keymapper.onboarding.OnboardingUseCaseImpl
 import io.github.sds100.keymapper.reroutekeyevents.RerouteKeyEventsUseCaseImpl
 import io.github.sds100.keymapper.shizuku.ShizukuInputEventInjector
+import io.github.sds100.keymapper.sorting.ObserveKeyMapFieldSortOrderUseCase
+import io.github.sds100.keymapper.sorting.ObserveKeyMapSortOrderUseCase
+import io.github.sds100.keymapper.sorting.ObserveKeyMapsSorterUseCase
+import io.github.sds100.keymapper.sorting.SetKeyMapSortOrderUseCase
+import io.github.sds100.keymapper.sorting.ToggleKeyMapFieldSortOrderUseCase
 import io.github.sds100.keymapper.system.Shell
 import io.github.sds100.keymapper.system.accessibility.ControlAccessibilityServiceUseCase
 import io.github.sds100.keymapper.system.accessibility.ControlAccessibilityServiceUseCaseImpl
@@ -231,4 +236,25 @@ object UseCases {
             keyEventRelayService,
             ServiceLocator.inputMethodAdapter(ctx),
         )
+
+    fun observeKeyMapFieldSortOrderUseCase(ctx: Context) = ObserveKeyMapFieldSortOrderUseCase(
+        ServiceLocator.settingsRepository(ctx),
+    )
+
+    fun observeKeyMapsSorter(ctx: Context) = ObserveKeyMapsSorterUseCase(
+        observeKeyMapFieldSortOrderUseCase(ctx),
+        observeKeyMapSortOrderUseCase(ctx),
+    )
+
+    fun setKeyMapFieldSortOrderUseCase(ctx: Context) = ToggleKeyMapFieldSortOrderUseCase(
+        ServiceLocator.settingsRepository(ctx),
+    )
+
+    fun observeKeyMapSortOrderUseCase(ctx: Context) = ObserveKeyMapSortOrderUseCase(
+        ServiceLocator.settingsRepository(ctx),
+    )
+
+    fun setKeyMapSortOrderUseCase(ctx: Context) = SetKeyMapSortOrderUseCase(
+        ServiceLocator.settingsRepository(ctx),
+    )
 }

app/src/main/java/io/github/sds100/keymapper/constraints/ConstraintState.kt

@@ -1,5 +1,6 @@
 package io.github.sds100.keymapper.constraints
 
+import io.github.sds100.keymapper.mappings.keymaps.KeyMap
 import kotlinx.serialization.Serializable
 
 /**
@@ -11,3 +12,41 @@ data class ConstraintState(
     val constraints: Set<Constraint> = emptySet(),
     val mode: ConstraintMode = ConstraintMode.AND,
 )
+
+// Comparator.reversed() requires API level 24
+class KeyMapConstraintsComparator(
+    private val reverse: Boolean = false,
+) : Comparator<KeyMap> {
+    override fun compare(
+        keyMap: KeyMap?,
+        otherKeyMap: KeyMap?,
+    ): Int {
+        // TODO
+
+        if (keyMap == null || otherKeyMap == null) {
+            return 0
+        }
+
+        for (i in 0 until keyMap.constraintState.constraints.size.coerceAtMost(otherKeyMap.constraintState.constraints.size)) {
+            val constraint1 = keyMap.constraintState.constraints.elementAt(i)
+            val constraint2 = otherKeyMap.constraintState.constraints.elementAt(i)
+
+            val result = constraint1.javaClass.name.compareTo(constraint2.javaClass.name)
+
+            if (result != 0) {
+                return doFinal(result)
+            }
+        }
+
+        val comparison =
+            keyMap.constraintState.constraints.size.compareTo(otherKeyMap.constraintState.constraints.size)
+
+        return doFinal(comparison)
+    }
+
+    fun doFinal(result: Int) = if (reverse) {
+        result * -1
+    } else {
+        result
+    }
+}

app/src/main/java/io/github/sds100/keymapper/data/Keys.kt

@@ -70,4 +70,11 @@ object Keys {
     val savedWifiSSIDs = stringSetPreferencesKey("key_saved_wifi_ssids")
 
     val neverShowDndError = booleanPreferencesKey("key_never_show_dnd_error")
+
+    // true = ascending, false = descending
+    val sortTriggerAscending = booleanPreferencesKey("key_sort_trigger_ascending")
+    val sortActionsAscending = booleanPreferencesKey("key_sort_actions_ascending")
+    val sortConstraintsAscending = booleanPreferencesKey("key_sort_constraints_ascending")
+    val sortOptionsAscending = booleanPreferencesKey("key_sort_options_ascending")
+    val sortOrder = stringPreferencesKey("key_sort_order")
 }

app/src/main/java/io/github/sds100/keymapper/home/HomeFragment.kt

@@ -305,6 +305,19 @@ class HomeFragment : Fragment() {
                 backupFingerprintMapsLauncher.launch(BackupUtils.createFingerprintMapsFileName())
             }
         }
+
+        viewLifecycleOwner.launchRepeatOnLifecycle(Lifecycle.State.RESUMED) {
+            binding.appBar.setOnMenuItemClickListener {
+                when (it.itemId) {
+                    R.id.action_sort -> {
+                        findNavController().navigate(R.id.action_global_sortingFragment)
+                        true
+                    }
+
+                    else -> false
+                }
+            }
+        }
     }
 
     override fun onDestroyView() {

app/src/main/java/io/github/sds100/keymapper/mappings/keymaps/KeyMap.kt

@@ -106,3 +106,37 @@ object KeyMapEntityMapper {
         )
     }
 }
+
+// Comparator.reversed() requires API level 24
+class KeyMapOptionsComparator(
+    private val reverse: Boolean = false,
+) : Comparator<KeyMap> {
+    override fun compare(
+        keyMap: KeyMap?,
+        otherKeyMap: KeyMap?,
+    ): Int {
+        // TODO
+
+        if (keyMap == null || otherKeyMap == null) {
+            return 0
+        }
+
+        // Compare the options
+
+        if (keyMap.vibrate != otherKeyMap.vibrate) {
+            return doFinal(keyMap.vibrate.compareTo(otherKeyMap.vibrate))
+        }
+
+        if (keyMap.showToast != otherKeyMap.showToast) {
+            return doFinal(keyMap.showToast.compareTo(otherKeyMap.showToast))
+        }
+
+        return 0
+    }
+
+    fun doFinal(result: Int) = if (reverse) {
+        result * -1
+    } else {
+        result
+    }
+}

app/src/main/java/io/github/sds100/keymapper/mappings/keymaps/KeyMapAction.kt

@@ -200,3 +200,39 @@ object KeymapActionEntityMapper {
         )
     }
 }
+
+// Comparator.reversed() requires API level 24
+class KeyMapActionsComparator(
+    private val reverse: Boolean = false,
+) : Comparator<KeyMap> {
+    override fun compare(
+        keyMap: KeyMap?,
+        otherKeyMap: KeyMap?,
+    ): Int {
+        // TODO
+        if (keyMap == null || otherKeyMap == null) {
+            return 0
+        }
+
+        for (i in 0 until keyMap.actionList.size.coerceAtMost(otherKeyMap.actionList.size)) {
+            val action1 = keyMap.actionList[i]
+            val action2 = otherKeyMap.actionList[i]
+
+            val result = action1.data.id.ordinal.compareTo(action2.data.id.ordinal)
+
+            if (result != 0) {
+                return doFinal(result)
+            }
+        }
+
+        val comparison = keyMap.actionList.size.compareTo(otherKeyMap.actionList.size)
+
+        return doFinal(comparison)
+    }
+
+    fun doFinal(result: Int) = if (reverse) {
+        result * -1
+    } else {
+        result
+    }
+}

app/src/main/java/io/github/sds100/keymapper/mappings/keymaps/KeyMapField.kt

@@ -0,0 +1,19 @@
+package io.github.sds100.keymapper.mappings.keymaps
+
+import io.github.sds100.keymapper.constraints.KeyMapConstraintsComparator
+import io.github.sds100.keymapper.mappings.keymaps.trigger.KeyMapTriggerComparator
+
+enum class KeyMapField {
+    TRIGGER,
+    ACTIONS,
+    CONSTRAINTS,
+    OPTIONS,
+    ;
+
+    fun getComparator(reverse: Boolean) = when (this) {
+        TRIGGER -> KeyMapTriggerComparator(reverse)
+        ACTIONS -> KeyMapActionsComparator(reverse)
+        CONSTRAINTS -> KeyMapConstraintsComparator(reverse)
+        OPTIONS -> KeyMapOptionsComparator(reverse)
+    }
+}

app/src/main/java/io/github/sds100/keymapper/mappings/keymaps/ListKeyMapsUseCase.kt

@@ -1,13 +1,15 @@
 package io.github.sds100.keymapper.mappings.keymaps
 
 import io.github.sds100.keymapper.backup.BackupManager
+import io.github.sds100.keymapper.sorting.ObserveKeyMapsSorterUseCase
 import io.github.sds100.keymapper.util.Result
 import io.github.sds100.keymapper.util.State
 import io.github.sds100.keymapper.util.mapData
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.channelFlow
 import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.withContext
 
 /**
@@ -17,23 +19,25 @@ class ListKeyMapsUseCaseImpl(
     private val keyMapRepository: KeyMapRepository,
     private val backupManager: BackupManager,
     displayKeyMapUseCase: DisplayKeyMapUseCase,
+    private val observeKeyMapsSorterUseCase: ObserveKeyMapsSorterUseCase,
 ) : ListKeyMapsUseCase,
     DisplayKeyMapUseCase by displayKeyMapUseCase {
 
     override val keyMapList: Flow<State<List<KeyMap>>> = channelFlow {
         send(State.Loading)
 
-        keyMapRepository.keyMapList.collectLatest { keyMapEntitiesState ->
-            send(State.Loading)
-
+        combine(
+            keyMapRepository.keyMapList,
+            observeKeyMapsSorterUseCase(),
+        ) { keyMapEntitiesState, sorter ->
+            keyMapEntitiesState.mapData { keyMapEntities ->
+                keyMapEntities
+                    .map { KeyMapEntityMapper.fromEntity(it) }
+                    .sortedWith(sorter)
+            }
+        }.collectLatest {
             withContext(Dispatchers.Default) {
-                val keyMaps = keyMapEntitiesState.mapData { keyMapEntities ->
-                    keyMapEntities.map {
-                        KeyMapEntityMapper.fromEntity(it)
-                    }
-                }
-
-                send(keyMaps)
+                send(it)
             }
         }
     }

app/src/main/java/io/github/sds100/keymapper/mappings/keymaps/trigger/KeyMapTrigger.kt

@@ -4,6 +4,7 @@ import io.github.sds100.keymapper.data.entities.Extra
 import io.github.sds100.keymapper.data.entities.TriggerEntity
 import io.github.sds100.keymapper.data.entities.getData
 import io.github.sds100.keymapper.mappings.ClickType
+import io.github.sds100.keymapper.mappings.keymaps.KeyMap
 import io.github.sds100.keymapper.system.keyevents.KeyEventUtils
 import io.github.sds100.keymapper.util.valueOrNull
 import kotlinx.serialization.Serializable
@@ -165,3 +166,28 @@ object KeymapTriggerEntityMapper {
         )
     }
 }
+
+// Comparator.reversed() requires API level 24
+class KeyMapTriggerComparator(
+    private val reverse: Boolean = false,
+) : Comparator<KeyMap> {
+    override fun compare(
+        keyMap: KeyMap?,
+        otherKeyMap: KeyMap?,
+    ): Int {
+        // TODO
+        if (keyMap == null || otherKeyMap == null) {
+            return 0
+        }
+
+        val result = 0
+
+        return doFinal(result)
+    }
+
+    fun doFinal(result: Int) = if (reverse) {
+        result * -1
+    } else {
+        result
+    }
+}

app/src/main/java/io/github/sds100/keymapper/sorting/ObserveKeyMapFieldSortOrderUseCase.kt

@@ -0,0 +1,38 @@
+package io.github.sds100.keymapper.sorting
+
+import io.github.sds100.keymapper.data.Keys
+import io.github.sds100.keymapper.data.repositories.PreferenceRepository
+import io.github.sds100.keymapper.mappings.keymaps.KeyMapField
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+/**
+ * Observes the sorting order of a key map field, indicating the order in which the specified field
+ * should be sorted.
+ */
+class ObserveKeyMapFieldSortOrderUseCase(
+    private val preferenceRepository: PreferenceRepository,
+) {
+    /**
+     * Observe the sorting order of the key map field.
+     *
+     * @param field The key map field to observe.
+     * @return A flow of the sorting order.
+     */
+    operator fun invoke(field: KeyMapField): Flow<SortOrder> {
+        val key = when (field) {
+            KeyMapField.TRIGGER -> Keys.sortTriggerAscending
+            KeyMapField.ACTIONS -> Keys.sortActionsAscending
+            KeyMapField.CONSTRAINTS -> Keys.sortConstraintsAscending
+            KeyMapField.OPTIONS -> Keys.sortOptionsAscending
+        }
+
+        return preferenceRepository.get(key).map {
+            when (it) {
+                // Default value is ascending
+                null, true -> SortOrder.ASCENDING
+                false -> SortOrder.DESCENDING
+            }
+        }
+    }
+}

app/src/main/java/io/github/sds100/keymapper/sorting/ObserveKeyMapSortOrderUseCase.kt

@@ -0,0 +1,46 @@
+package io.github.sds100.keymapper.sorting
+
+import io.github.sds100.keymapper.data.Keys
+import io.github.sds100.keymapper.data.repositories.PreferenceRepository
+import io.github.sds100.keymapper.mappings.keymaps.KeyMapField
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+/**
+ * Observes the order in which key map fields should be sorted, prioritizing specific fields.
+ * For example, if the order is [TRIGGER, ACTIONS, CONSTRAINTS, OPTIONS],
+ * it means the key maps should be sorted first by trigger, then by actions, followed by constraints,
+ * and finally by options.
+ */
+class ObserveKeyMapSortOrderUseCase(
+    private val preferenceRepository: PreferenceRepository,
+) {
+    private val default by lazy {
+        listOf(
+            KeyMapField.TRIGGER,
+            KeyMapField.ACTIONS,
+            KeyMapField.CONSTRAINTS,
+            KeyMapField.OPTIONS,
+        )
+    }
+
+    operator fun invoke(): Flow<List<KeyMapField>> {
+        return preferenceRepository
+            .get(Keys.sortOrder)
+            .map {
+                val result = runCatching {
+                    it
+                        ?.split(",")
+                        ?.map { KeyMapField.valueOf(it) }
+                        ?: default
+                }.getOrDefault(default).distinct()
+
+                // If the result is not the expected size it means that the preference is corrupted
+                if (result.size != 4) {
+                    return@map default
+                }
+
+                result
+            }
+    }
+}