Merge pull request #1456 from keymapperorg/develop

Version 2.8.1

Author: sds100

CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.8.1](https://github.com/sds100/KeyMapper/releases/tag/v2.8.1)
+
+#### 18 February 2025
+
+## Bug fixes
+
+- #1433 open Key Mapper by default and not the Assistant Trigger app.
+- #1386 wait for sequence trigger timeout before triggering other overlapping triggers.
+- #1449 improve the key mapper crashed dialog.
+- #1415 make the discard changes dialog less confusing.
+- #1440 do not show the "Button not detected?" bottom sheet every time you open the config key map screen in some cases.
+- #1447 the app bar when configuring an Intent action would extend to the top of the screen.
+- #1444 use the correct icon for screen on/off constraints.
+
 ## [2.8.0](https://github.com/sds100/KeyMapper/releases/tag/v2.8.0)
 
 #### 13 February 2025

README.md

@@ -1,5 +1,4 @@
-**Project back under slower development.**
-> **UPDATE**: I miss working on this project and Key Mapper still has so much potential so I am back! 😊
+**UPDATE**: I miss working on this project and Key Mapper still has so much potential so I am back! 😊
 > 
 > Well, working on this project was a fun ride 🎢! This project has taught me so much about Android, software development and how to collaborate with an online community. It has been my dream to lead a big FOSS project with people from all over the world so a **huge** thank you goes to everyone that spread the word and helped on GitHub along the way ☺.
 >

app/src/free/java/io/github/sds100/keymapper/mappings/keymaps/detection/KeyMapController.kt

@@ -249,7 +249,7 @@ class KeyMapController(
                     MutableList(triggers.size) { mutableSetOf<Int>() }
 
                 for (triggerIndex in parallelTriggers) {
-                    val trigger = triggers[triggerIndex]
+                    val parallelTrigger = triggers[triggerIndex]
 
                     otherTriggerLoop@ for (otherTriggerIndex in sequenceTriggers) {
                         val otherTrigger = triggers[otherTriggerIndex]
@@ -259,7 +259,7 @@ class KeyMapController(
                             continue@otherTriggerLoop
                         }
 
-                        for ((keyIndex, key) in trigger.keys.withIndex()) {
+                        for ((keyIndex, key) in parallelTrigger.keys.withIndex()) {
                             var lastMatchedIndex: Int? = null
 
                             for ((otherKeyIndex, otherKey) in otherTrigger.keys.withIndex()) {
@@ -271,7 +271,7 @@ class KeyMapController(
                                         continue@otherTriggerLoop
                                     }
 
-                                    if (keyIndex == trigger.keys.lastIndex) {
+                                    if (keyIndex == parallelTrigger.keys.lastIndex) {
                                         sequenceTriggersOverlappingParallelTriggers[triggerIndex].add(
                                             otherTriggerIndex,
                                         )
@@ -489,30 +489,36 @@ class KeyMapController(
 
     private var modifierKeyEventActions: Boolean = false
     private var notModifierKeyEventActions: Boolean = false
-    private var keyCodesToImitateUpAction: MutableSet<Int> = mutableSetOf<Int>()
+    private var keyCodesToImitateUpAction: MutableSet<Int> = mutableSetOf()
     private var metaStateFromActions: Int = 0
     private var metaStateFromKeyEvent: Int = 0
 
-    private val eventDownTimeMap: MutableMap<Event, Long> = mutableMapOf<Event, Long>()
+    private val eventDownTimeMap: MutableMap<Event, Long> = mutableMapOf()
+
+    /**
+     * This solves issue #1386. This stores the jobs that will wait until the sequence trigger
+     * times out and check whether the overlapping sequence trigger was indeed triggered.
+     */
+    private val performActionsAfterSequenceTriggerTimeout: MutableMap<Int, Job> = mutableMapOf()
 
     /**
      * The indexes of parallel triggers that didn't have their actions performed because there is a matching trigger but
      * for a long-press. These actions should only be performed if the long-press fails, otherwise when the user
      * holds down the trigger keys for the long-press trigger, actions from both triggers will be performed.
      */
-    private val performActionsOnFailedLongPress: MutableSet<Int> = mutableSetOf<Int>()
+    private val performActionsOnFailedLongPress: MutableSet<Int> = mutableSetOf()
 
     /**
      * The indexes of parallel triggers that didn't have their actions performed because there is a matching trigger but
      * for a double-press. These actions should only be performed if the double-press fails, otherwise each time the user
      * presses the keys for the double press, actions from both triggers will be performed.
      */
-    private val performActionsOnFailedDoublePress: MutableSet<Int> = mutableSetOf<Int>()
+    private val performActionsOnFailedDoublePress: MutableSet<Int> = mutableSetOf()
 
     /**
      * Maps jobs to perform an action after a long press to their corresponding parallel trigger index
      */
-    private val parallelTriggerLongPressJobs: SparseArrayCompat<Job> = SparseArrayCompat<Job>()
+    private val parallelTriggerLongPressJobs: SparseArrayCompat<Job> = SparseArrayCompat()
 
     /**
      * Keys that are detected through an input method will potentially send multiple DOWN key events
@@ -849,31 +855,63 @@ class KeyMapController(
                     mappedToParallelTriggerAction = true
                     parallelTriggersAwaitingReleaseAfterBeingTriggered[triggerIndex] = true
 
-                    val actionKeys = triggerActions[triggerIndex]
+                    // See issue #1386.
+                    val overlappingSequenceTrigger =
+                        sequenceTriggersOverlappingParallelTriggers[triggerIndex]
+                            // Only consider the sequence triggers where this
+                            // short press trigger has been already pressed
+                            // or will be pressed next.
+                            .filter {
+                                for (i in 0..(lastMatchedEventIndices[it] + 1)) {
+                                    val matchingEvent = triggers[it].matchingEventAtIndex(
+                                        event.withShortPress,
+                                        i,
+                                    )
+
+                                    if (matchingEvent) {
+                                        return@filter true
+                                    }
+                                }
+
+                                return@filter false
+                            }
+                            .maxByOrNull { sequenceTriggerTimeout(triggers[it]) }
+
+                    if (overlappingSequenceTrigger == null) {
+                        val actionKeys = triggerActions[triggerIndex]
 
-                    actionKeys.forEach { actionKey ->
-                        val action = actionMap[actionKey] ?: return@forEach
+                        actionKeys.forEach { actionKey ->
+                            val action = actionMap[actionKey] ?: return@forEach
 
-                        if (action.data is ActionData.InputKeyEvent) {
-                            val actionKeyCode = action.data.keyCode
+                            if (action.data is ActionData.InputKeyEvent) {
+                                val actionKeyCode = action.data.keyCode
 
-                            if (isModifierKey(actionKeyCode)) {
-                                val actionMetaState =
-                                    InputEventUtils.modifierKeycodeToMetaState(actionKeyCode)
-                                metaStateFromActions =
-                                    metaStateFromActions.withFlag(actionMetaState)
+                                if (isModifierKey(actionKeyCode)) {
+                                    val actionMetaState =
+                                        InputEventUtils.modifierKeycodeToMetaState(actionKeyCode)
+                                    metaStateFromActions =
+                                        metaStateFromActions.withFlag(actionMetaState)
+                                }
                             }
-                        }
 
-                        detectedShortPressTriggers.add(triggerIndex)
+                            detectedShortPressTriggers.add(triggerIndex)
 
-                        val vibrateDuration = when {
-                            trigger.vibrate -> vibrateDuration(trigger)
-                            forceVibrate.value -> defaultVibrateDuration.value
-                            else -> -1L
+                            val vibrateDuration = when {
+                                trigger.vibrate -> vibrateDuration(trigger)
+                                forceVibrate.value -> defaultVibrateDuration.value
+                                else -> -1L
+                            }
+
+                            vibrateDurations.add(vibrateDuration)
                         }
+                    } else {
+                        performActionsAfterSequenceTriggerTimeout[triggerIndex]?.cancel()
 
-                        vibrateDurations.add(vibrateDuration)
+                        performActionsAfterSequenceTriggerTimeout[triggerIndex] =
+                            performActionsAfterSequenceTriggerTimeout(
+                                triggerIndex,
+                                overlappingSequenceTrigger,
+                            )
                     }
                 }
             }
@@ -1443,14 +1481,14 @@ class KeyMapController(
         metaStateFromKeyEvent = 0
         keyCodesToImitateUpAction = mutableSetOf()
 
-        parallelTriggerLongPressJobs.valueIterator().forEach {
-            it.cancel()
-        }
-
+        parallelTriggerLongPressJobs.valueIterator().forEach { it.cancel() }
         parallelTriggerLongPressJobs.clear()
 
         parallelTriggerActionPerformers.values.forEach { it.reset() }
         sequenceTriggerActionPerformers.values.forEach { it.reset() }
+
+        performActionsAfterSequenceTriggerTimeout.forEach { (_, job) -> job.cancel() }
+        performActionsAfterSequenceTriggerTimeout.clear()
     }
 
     /**
@@ -1499,6 +1537,40 @@ class KeyMapController(
         return detectedTriggerIndexes.isNotEmpty()
     }
 
+    /**
+     * For parallel triggers only.
+     */
+    private fun performActionsAfterSequenceTriggerTimeout(
+        triggerIndex: Int,
+        sequenceTriggerIndex: Int,
+    ) = coroutineScope.launch {
+        val timeout = sequenceTriggerTimeout(triggers[sequenceTriggerIndex])
+
+        delay(timeout)
+
+        // If it equals -1 then it means the sequence trigger was triggered
+        // and it reset the counter.
+        if (lastMatchedEventIndices[sequenceTriggerIndex] == -1) {
+            return@launch
+        }
+
+        parallelTriggerActionPerformers[triggerIndex]?.onTriggered(
+            calledOnTriggerRelease = true,
+            metaState = metaStateFromActions.withFlag(metaStateFromKeyEvent),
+        )
+
+        if (triggers[triggerIndex].vibrate ||
+            forceVibrate.value ||
+            triggers[triggerIndex].longPressDoubleVibration
+        ) {
+            useCase.vibrate(vibrateDuration(triggers[triggerIndex]))
+        }
+
+        if (triggers[triggerIndex].showToast) {
+            useCase.showTriggeredToast()
+        }
+    }
+
     private fun encodeActionList(actions: List<KeyMapAction>): IntArray = actions.map { getActionKey(it) }.toIntArray()
 
     /**

app/src/main/AndroidManifest.xml

@@ -87,11 +87,17 @@
             android:theme="@style/Theme.App.Starting">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="android.intent.category.LAUNCHER" />
+                <!-- Set as default so the Assistant Trigger app isn't opened by default. -->
+                <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
+                <!-- Set as default so the Assistant Trigger app isn't opened by default. -->
+                <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
 

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

@@ -192,12 +192,12 @@ class ConstraintUiHelper(
         )
 
         Constraint.ScreenOff -> IconInfo(
-            drawable = getDrawable(R.drawable.ic_outline_stay_current_portrait_24),
+            drawable = getDrawable(R.drawable.ic_baseline_mobile_off_24),
             tintType = TintType.OnSurface,
         )
 
         Constraint.ScreenOn -> IconInfo(
-            drawable = getDrawable(R.drawable.ic_baseline_mobile_off_24),
+            drawable = getDrawable(R.drawable.ic_outline_stay_current_portrait_24),
             tintType = TintType.OnSurface,
         )
 
@@ -277,48 +277,6 @@ class ConstraintUiHelper(
         )
     }
 
-    /**
-     * Get a title for a constraint that is not specific to a particular instance.
-     */
-    fun getGenericTitle(constraint: Constraint): String = when (constraint) {
-        is Constraint.AppInForeground -> getString(
-            R.string.constraint_app_foreground_description,
-            "",
-        )
-
-        is Constraint.AppNotInForeground -> getString(
-            R.string.constraint_app_not_foreground_description,
-            "",
-        )
-
-        is Constraint.AppNotPlayingMedia -> TODO()
-        is Constraint.AppPlayingMedia -> TODO()
-        is Constraint.BtDeviceConnected -> TODO()
-        is Constraint.BtDeviceDisconnected -> TODO()
-        Constraint.Charging -> TODO()
-        Constraint.DeviceIsLocked -> TODO()
-        Constraint.DeviceIsUnlocked -> TODO()
-        Constraint.Discharging -> TODO()
-        is Constraint.FlashlightOff -> TODO()
-        is Constraint.FlashlightOn -> TODO()
-        is Constraint.ImeChosen -> TODO()
-        is Constraint.ImeNotChosen -> TODO()
-        Constraint.InPhoneCall -> TODO()
-        Constraint.MediaPlaying -> TODO()
-        Constraint.NoMediaPlaying -> TODO()
-        Constraint.NotInPhoneCall -> TODO()
-        is Constraint.OrientationCustom -> TODO()
-        Constraint.OrientationLandscape -> TODO()
-        Constraint.OrientationPortrait -> TODO()
-        Constraint.PhoneRinging -> TODO()
-        Constraint.ScreenOff -> TODO()
-        Constraint.ScreenOn -> TODO()
-        is Constraint.WifiConnected -> TODO()
-        is Constraint.WifiDisconnected -> TODO()
-        Constraint.WifiOff -> TODO()
-        Constraint.WifiOn -> TODO()
-    }
-
     private fun getAppIconInfo(packageName: String): IconInfo? = getAppIcon(packageName).handle(
         onSuccess = { IconInfo(it, TintType.None) },
         onError = { null },

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

@@ -48,7 +48,7 @@ class CreateConstraintUseCaseImpl(
 
         if (!savedWifiSSIDsList.contains(ssid)) {
             if (savedWifiSSIDsList.size == 3) {
-                savedWifiSSIDsList.removeLast()
+                savedWifiSSIDsList.removeAt(savedWifiSSIDsList.lastIndex)
             }
 
             if (savedWifiSSIDsList.isEmpty()) {

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

@@ -8,6 +8,7 @@ object PreferenceDefaults {
     const val DARK_THEME = "2"
 
     const val SHOW_TOAST_WHEN_AUTO_CHANGE_IME = true
+    const val CHANGE_IME_ON_INPUT_FOCUS = false
 
     const val FORCE_VIBRATE = false
     const val LONG_PRESS_DELAY = 500

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

@@ -1,6 +1,7 @@
 package io.github.sds100.keymapper.home
 
 import android.os.Bundle
+import android.view.View
 import androidx.activity.viewModels
 import androidx.core.os.bundleOf
 import androidx.fragment.app.Fragment
@@ -27,7 +28,12 @@ class FixAppKillingActivity : AppIntro2() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        viewModel.showPopups(this, findViewById(R.id.background))
+        val rootView: View = findViewById(R.id.background)
+
+        // Don't show behind the status/navigation bar on Android 15+
+        rootView.fitsSystemWindows = true
+        showStatusBar(true)
+        viewModel.showPopups(this, rootView)
 
         isSkipButtonEnabled = false
 

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

@@ -178,14 +178,14 @@ abstract class ConfigMappingFragment : Fragment() {
     private fun showOnBackPressedWarning() {
         viewLifecycleScope.launchWhenResumed {
             onBackPressedDialog = requireContext().materialAlertDialog {
-                titleResource = R.string.dialog_title_discard_changes
-                messageResource = R.string.dialog_message_discard_changes
+                titleResource = R.string.dialog_title_unsaved_changes
+                messageResource = R.string.dialog_message_unsaved_changes
 
-                positiveButton(R.string.pos_confirm) {
+                positiveButton(R.string.pos_discard_changes) {
                     findNavController().navigateUp()
                 }
 
-                negativeButton(R.string.neg_cancel) { it.cancel() }
+                negativeButton(R.string.neg_keep_editing) { it.cancel() }
             }
 
             onBackPressedDialog?.show()

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

@@ -95,14 +95,14 @@ class CreateKeyMapShortcutFragment : SimpleRecyclerViewFragment<KeyMapListItem>(
 
     private fun showOnBackPressedWarning() {
         requireContext().alertDialog {
-            titleResource = R.string.dialog_title_discard_changes
-            messageResource = R.string.dialog_message_discard_changes
+            titleResource = R.string.dialog_title_unsaved_changes
+            messageResource = R.string.dialog_message_unsaved_changes
 
-            positiveButton(R.string.pos_confirm) {
+            positiveButton(R.string.pos_discard_changes) {
                 requireActivity().finish()
             }
 
-            negativeButton(R.string.neg_cancel) { it.cancel() }
+            negativeButton(R.string.neg_keep_editing) { it.cancel() }
             show()
         }
     }