Merge branch 'feature/1918-input-key-event-actions-evdev' into develop

Author: sds100

CHANGELOG.md

@@ -7,6 +7,7 @@
 - #1915 ask user to remove "adb shell" from Shell command.
 - #1904 inform the user how to enable the accessibility service with PRO mode or ADB.
 - #1911 constraint for physical device orientation that ignores auto rotate setting.
+- #1918 improve how key event actions are performed with system bridge
 
 ## Bug fixes
 

base/src/main/java/io/github/sds100/keymapper/base/actions/PerformActionTriggerDevice.kt

@@ -0,0 +1,13 @@
+package io.github.sds100.keymapper.base.actions
+
+/**
+ * Identifies which device triggered the action.
+ */
+sealed class PerformActionTriggerDevice {
+    /**
+     * The action was triggered by an evdev-level input device.
+     */
+    data class Evdev(val deviceId: Int) : PerformActionTriggerDevice()
+
+    data object Default : PerformActionTriggerDevice()
+}

base/src/main/java/io/github/sds100/keymapper/base/actions/PerformActionsUseCase.kt

@@ -28,16 +28,13 @@ import io.github.sds100.keymapper.common.utils.KMError.SdkVersionTooLow
 import io.github.sds100.keymapper.common.utils.KMResult
 import io.github.sds100.keymapper.common.utils.Orientation
 import io.github.sds100.keymapper.common.utils.Success
-import io.github.sds100.keymapper.common.utils.dataOrNull
 import io.github.sds100.keymapper.common.utils.firstBlocking
 import io.github.sds100.keymapper.common.utils.getWordBoundaries
-import io.github.sds100.keymapper.common.utils.ifIsData
 import io.github.sds100.keymapper.common.utils.onFailure
 import io.github.sds100.keymapper.common.utils.onSuccess
 import io.github.sds100.keymapper.common.utils.otherwise
 import io.github.sds100.keymapper.common.utils.success
 import io.github.sds100.keymapper.common.utils.then
-import io.github.sds100.keymapper.common.utils.withFlag
 import io.github.sds100.keymapper.data.Keys
 import io.github.sds100.keymapper.data.PreferenceDefaults
 import io.github.sds100.keymapper.data.repositories.PreferenceRepository
@@ -52,7 +49,6 @@ import io.github.sds100.keymapper.system.devices.DevicesAdapter
 import io.github.sds100.keymapper.system.display.DisplayAdapter
 import io.github.sds100.keymapper.system.files.FileAdapter
 import io.github.sds100.keymapper.system.files.FileUtils
-import io.github.sds100.keymapper.system.inputevents.KeyEventUtils
 import io.github.sds100.keymapper.system.inputevents.Scancode
 import io.github.sds100.keymapper.system.inputmethod.InputMethodAdapter
 import io.github.sds100.keymapper.system.intents.IntentAdapter
@@ -78,12 +74,9 @@ import kotlin.math.absoluteValue
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeoutOrNull
 import timber.log.Timber
@@ -143,15 +136,19 @@ class PerformActionsUseCaseImpl @AssistedInject constructor(
         )
     }
 
-    private val injectKeyEventsWithSystemBridge: StateFlow<Boolean> =
-        settingsRepository.get(Keys.keyEventActionsUseSystemBridge)
-            .map { it ?: PreferenceDefaults.KEY_EVENT_ACTIONS_USE_SYSTEM_BRIDGE }
-            .stateIn(coroutineScope, SharingStarted.Eagerly, false)
+    private val performKeyEventActionDelegate: PerformKeyEventActionDelegate =
+        PerformKeyEventActionDelegate(
+            coroutineScope,
+            settingsRepository,
+            inputEventHub,
+            devicesAdapter,
+        )
 
     override suspend fun perform(
         action: ActionData,
         inputEventAction: InputEventAction,
         keyMetaState: Int,
+        device: PerformActionTriggerDevice,
     ) {
         /**
          * Is null if the action is being performed asynchronously
@@ -172,48 +169,12 @@ class PerformActionsUseCaseImpl @AssistedInject constructor(
             }
 
             is ActionData.InputKeyEvent -> {
-                val deviceId: Int = getDeviceIdForKeyEventAction(action)
-
-                // See issue #1683. Some apps ignore key events which do not have a source.
-                val source = when {
-                    KeyEventUtils.isDpadKeyCode(action.keyCode) -> InputDevice.SOURCE_DPAD
-                    KeyEventUtils.isGamepadButton(action.keyCode) -> InputDevice.SOURCE_GAMEPAD
-                    else -> InputDevice.SOURCE_KEYBOARD
-                }
-
-                val firstInputAction = if (inputEventAction == InputEventAction.UP) {
-                    KeyEvent.ACTION_UP
-                } else {
-                    KeyEvent.ACTION_DOWN
-                }
-
-                val model = InjectKeyEventModel(
-                    keyCode = action.keyCode,
-                    action = firstInputAction,
-                    metaState = keyMetaState.withFlag(action.metaState),
-                    deviceId = deviceId,
-                    source = source,
-                    repeatCount = 0,
-                    scanCode = 0,
+                result = performKeyEventActionDelegate.perform(
+                    action,
+                    inputEventAction,
+                    keyMetaState,
+                    device,
                 )
-
-                if (inputEventAction == InputEventAction.DOWN_UP) {
-                    result = inputEventHub.injectKeyEvent(
-                        model,
-                        useSystemBridgeIfAvailable = injectKeyEventsWithSystemBridge.value,
-                    )
-                        .then {
-                            inputEventHub.injectKeyEvent(
-                                model.copy(action = KeyEvent.ACTION_UP),
-                                useSystemBridgeIfAvailable = injectKeyEventsWithSystemBridge.value,
-                            )
-                        }
-                } else {
-                    result = inputEventHub.injectKeyEvent(
-                        model,
-                        useSystemBridgeIfAvailable = injectKeyEventsWithSystemBridge.value,
-                    )
-                }
             }
 
             is ActionData.PhoneCall -> {
@@ -1108,53 +1069,6 @@ class PerformActionsUseCaseImpl @AssistedInject constructor(
             .map { it ?: PreferenceDefaults.HOLD_DOWN_DURATION }
             .map { it.toLong() }
 
-    private fun getDeviceIdForKeyEventAction(action: ActionData.InputKeyEvent): Int {
-        if (action.device?.descriptor == null) {
-            // automatically select a game controller as the input device for game controller key events
-
-            if (KeyEventUtils.isGamepadKeyCode(action.keyCode)) {
-                devicesAdapter.connectedInputDevices.value.ifIsData { inputDevices ->
-                    val device = inputDevices.find { it.isGameController }
-
-                    if (device != null) {
-                        return device.id
-                    }
-                }
-            }
-
-            return 0
-        }
-
-        val inputDevices = devicesAdapter.connectedInputDevices.value
-
-        val devicesWithSameDescriptor =
-            inputDevices.dataOrNull()
-                ?.filter { it.descriptor == action.device.descriptor }
-                ?: emptyList()
-
-        if (devicesWithSameDescriptor.isEmpty()) {
-            return -1
-        }
-
-        if (devicesWithSameDescriptor.size == 1) {
-            return devicesWithSameDescriptor[0].id
-        }
-
-        /*
-        if there are multiple devices use the device that supports the key
-        code. if none do then use the first one
-         */
-        val deviceThatHasKey = devicesWithSameDescriptor.singleOrNull {
-            devicesAdapter.deviceHasKey(it.id, action.keyCode)
-        }
-
-        val device = deviceThatHasKey
-            ?: devicesWithSameDescriptor.singleOrNull { it.name == action.device.name }
-            ?: devicesWithSameDescriptor[0]
-
-        return device.id
-    }
-
     private fun closeStatusBarShade(): KMResult<*> {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             return service
@@ -1233,6 +1147,7 @@ interface PerformActionsUseCase {
         action: ActionData,
         inputEventAction: InputEventAction = InputEventAction.DOWN_UP,
         keyMetaState: Int = 0,
+        device: PerformActionTriggerDevice = PerformActionTriggerDevice.Default,
     )
 
     fun getErrorSnapshot(): ActionErrorSnapshot