fix: improve how key events are inputted with Shizuku

Author: sds100

CHANGELOG.md

@@ -1,3 +1,9 @@
+## [3.0.1](https://github.com/sds100/KeyMapper/releases/tag/v3.0.1)
+
+## Bug fixes
+
+- Inputting key events with Shizuku does not crash the app if a Key Mapper keyboard is being used at the same time. And latency when inputting key events has been improved in some apps.
+
 ## [3.0.0](https://github.com/sds100/KeyMapper/releases/tag/v3.0.0)
 
 _See the changes from previous 3.0 Beta releases._

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

@@ -142,7 +142,7 @@ object UseCases {
         ServiceLocator.intentAdapter(ctx),
         getActionError(ctx),
         keyMapperImeMessenger(ctx, keyEventRelayService),
-        ShizukuInputEventInjector(),
+        ShizukuInputEventInjector(coroutineScope = ServiceLocator.appCoroutineScope(ctx)),
         ServiceLocator.packageManagerAdapter(ctx),
         ServiceLocator.appShortcutAdapter(ctx),
         ServiceLocator.popupMessageAdapter(ctx),
@@ -179,11 +179,12 @@ object UseCases {
         ServiceLocator.audioAdapter(ctx),
         keyMapperImeMessenger(ctx, keyEventRelayService),
         service,
-        ShizukuInputEventInjector(),
+        ShizukuInputEventInjector(ServiceLocator.appCoroutineScope(ctx)),
         ServiceLocator.popupMessageAdapter(ctx),
         ServiceLocator.permissionAdapter(ctx),
         ServiceLocator.resourceProvider(ctx),
         ServiceLocator.vibratorAdapter(ctx),
+        ServiceLocator.appCoroutineScope(ctx),
     )
 
     fun rerouteKeyEvents(ctx: Context, keyEventRelayService: KeyEventRelayServiceWrapper) = RerouteKeyEventsUseCaseImpl(

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

@@ -67,7 +67,6 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
 import splitties.bitflags.withFlag
 import timber.log.Timber
 
@@ -114,6 +113,7 @@ class PerformActionsUseCaseImpl(
             accessibilityService,
             shizukuInputEventInjector,
             permissionAdapter,
+            coroutineScope,
         )
     }
 
@@ -124,15 +124,15 @@ class PerformActionsUseCaseImpl(
         permissionAdapter.isGrantedFlow(Permission.SHIZUKU)
             .stateIn(coroutineScope, SharingStarted.Eagerly, false)
 
-    override fun perform(
+    override suspend fun perform(
         action: ActionData,
         inputEventType: InputEventType,
         keyMetaState: Int,
     ) {
         /**
          * Is null if the action is being performed asynchronously
          */
-        val result: Result<*>?
+        val result: Result<*>
 
         when (action) {
             is ActionData.App -> {
@@ -254,20 +254,15 @@ class PerformActionsUseCaseImpl(
             }
 
             is ActionData.SwitchKeyboard -> {
-                coroutineScope.launch {
-                    inputMethodAdapter
-                        .chooseImeWithoutUserInput(action.imeId)
-                        .onSuccess {
-                            val message = resourceProvider.getString(
-                                R.string.toast_chose_keyboard,
-                                it.label,
-                            )
-                            popupMessageAdapter.showPopupMessage(message)
-                        }
-                        .showErrorMessageOnFail()
-                }
-
-                result = null
+                result = inputMethodAdapter
+                    .chooseImeWithoutUserInput(action.imeId)
+                    .onSuccess {
+                        val message = resourceProvider.getString(
+                            R.string.toast_chose_keyboard,
+                            it.label,
+                        )
+                        popupMessageAdapter.showPopupMessage(message)
+                    }
             }
 
             is ActionData.Volume.Down -> {
@@ -578,14 +573,10 @@ class PerformActionsUseCaseImpl(
             }
 
             is ActionData.GoLastApp -> {
-                coroutineScope.launch {
-                    accessibilityService.doGlobalAction(AccessibilityService.GLOBAL_ACTION_RECENTS)
-                    delay(100)
+                accessibilityService.doGlobalAction(AccessibilityService.GLOBAL_ACTION_RECENTS)
+                delay(100)
+                result =
                     accessibilityService.doGlobalAction(AccessibilityService.GLOBAL_ACTION_RECENTS)
-                        .showErrorMessageOnFail()
-                }
-
-                result = null
             }
 
             is ActionData.OpenMenu -> {
@@ -711,11 +702,11 @@ class PerformActionsUseCaseImpl(
 
             is ActionData.Screenshot -> {
                 if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
-                    coroutineScope.launch {
-                        val picturesFolder = fileAdapter.getPicturesFolder()
-                        val screenshotsFolder = "$picturesFolder/Screenshots"
-                        val fileDate = FileUtils.createFileDate()
+                    val picturesFolder = fileAdapter.getPicturesFolder()
+                    val screenshotsFolder = "$picturesFolder/Screenshots"
+                    val fileDate = FileUtils.createFileDate()
 
+                    result =
                         suAdapter.execute("mkdir -p $screenshotsFolder; screencap -p $screenshotsFolder/Screenshot_$fileDate.png")
                             .onSuccess {
                                 // Wait 3 seconds so the message isn't shown in the screenshot.
@@ -726,9 +717,7 @@ class PerformActionsUseCaseImpl(
                                         R.string.toast_screenshot_taken,
                                     ),
                                 )
-                            }.showErrorMessageOnFail()
-                    }
-                    result = null
+                            }
                 } else {
                     result =
                         accessibilityService.doGlobalAction(AccessibilityService.GLOBAL_ACTION_TAKE_SCREENSHOT)
@@ -781,19 +770,11 @@ class PerformActionsUseCaseImpl(
             }
 
             ActionData.DismissAllNotifications -> {
-                coroutineScope.launch {
-                    notificationReceiverAdapter.send(ServiceEvent.DismissAllNotifications)
-                }
-
-                result = null
+                result = notificationReceiverAdapter.send(ServiceEvent.DismissAllNotifications)
             }
 
             ActionData.DismissLastNotification -> {
-                coroutineScope.launch {
-                    notificationReceiverAdapter.send(ServiceEvent.DismissLastNotification)
-                }
-
-                result = null
+                result = notificationReceiverAdapter.send(ServiceEvent.DismissLastNotification)
             }
 
             ActionData.AnswerCall -> {
@@ -815,27 +796,23 @@ class PerformActionsUseCaseImpl(
             }
 
             is ActionData.HttpRequest -> {
-                coroutineScope.launch {
-                    networkAdapter.sendHttpRequest(
-                        method = action.method,
-                        url = action.url,
-                        body = action.body,
-                        authorizationHeader = action.authorizationHeader,
-                    ).showErrorMessageOnFail()
-                }
-
-                result = null
+                result = networkAdapter.sendHttpRequest(
+                    method = action.method,
+                    url = action.url,
+                    body = action.body,
+                    authorizationHeader = action.authorizationHeader,
+                )
             }
         }
 
         when (result) {
-            null, is Success -> Timber.d("Performed action $action, input event type: $inputEventType, key meta state: $keyMetaState")
+            is Success -> Timber.d("Performed action $action, input event type: $inputEventType, key meta state: $keyMetaState")
             is Error -> Timber.d(
                 "Failed to perform action $action, reason: ${result.getFullMessage(resourceProvider)}, action: $action, input event type: $inputEventType, key meta state: $keyMetaState",
             )
         }
 
-        result?.showErrorMessageOnFail()
+        result.showErrorMessageOnFail()
     }
 
     override fun getErrorSnapshot(): ActionErrorSnapshot {
@@ -925,7 +902,7 @@ interface PerformActionsUseCase {
     val defaultRepeatDelay: Flow<Long>
     val defaultRepeatRate: Flow<Long>
 
-    fun perform(
+    suspend fun perform(
         action: ActionData,
         inputEventType: InputEventType = InputEventType.DOWN_UP,
         keyMetaState: Int = 0,

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

@@ -127,7 +127,7 @@ abstract class SimpleMappingController(
         }
     }
 
-    private fun performAction(
+    private suspend fun performAction(
         action: Action,
         inputEventType: InputEventType = InputEventType.DOWN_UP,
     ) {
@@ -172,20 +172,22 @@ abstract class SimpleMappingController(
     }
 
     fun reset() {
-        repeatJobs.values.forEach { jobs ->
+        for (jobs in repeatJobs.values) {
             jobs.forEach { it.cancel() }
         }
 
         repeatJobs.clear()
 
-        performActionJobs.values.forEach {
-            it.cancel()
+        for (job in performActionJobs.values) {
+            job.cancel()
         }
 
         performActionJobs.clear()
 
-        actionsBeingHeldDown.forEach {
-            performAction(it, InputEventType.UP)
+        coroutineScope.launch {
+            for (it in actionsBeingHeldDown) {
+                performAction(it, InputEventType.UP)
+            }
         }
 
         actionsBeingHeldDown.clear()

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

@@ -32,11 +32,14 @@ import io.github.sds100.keymapper.util.InputEventType
 import io.github.sds100.keymapper.util.State
 import io.github.sds100.keymapper.util.dataOrNull
 import io.github.sds100.keymapper.util.ui.ResourceProvider
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import timber.log.Timber
 
 /**
@@ -58,6 +61,7 @@ class DetectKeyMapsUseCaseImpl(
     private val permissionAdapter: PermissionAdapter,
     private val resourceProvider: ResourceProvider,
     private val vibrator: VibratorAdapter,
+    private val coroutineScope: CoroutineScope,
 ) : DetectKeyMapsUseCase {
 
     companion object {
@@ -164,6 +168,7 @@ class DetectKeyMapsUseCaseImpl(
         accessibilityService,
         shizukuInputEventInjector,
         permissionAdapter,
+        coroutineScope,
     )
 
     override val forceVibrate: Flow<Boolean> =
@@ -189,18 +194,20 @@ class DetectKeyMapsUseCaseImpl(
         inputEventType: InputEventType,
         scanCode: Int,
     ) {
+        val model = InputKeyModel(
+            keyCode,
+            inputEventType,
+            metaState,
+            deviceId,
+            scanCode,
+        )
+
         if (permissionAdapter.isGranted(Permission.SHIZUKU)) {
             Timber.d("Imitate button press ${KeyEvent.keyCodeToString(keyCode)} with Shizuku, key code: $keyCode, device id: $deviceId, meta state: $metaState, scan code: $scanCode")
 
-            shizukuInputEventInjector.inputKeyEvent(
-                InputKeyModel(
-                    keyCode,
-                    inputEventType,
-                    metaState,
-                    deviceId,
-                    scanCode,
-                ),
-            )
+            coroutineScope.launch {
+                shizukuInputEventInjector.inputKeyEvent(model)
+            }
         } else {
             Timber.d("Imitate button press ${KeyEvent.keyCodeToString(keyCode)}, key code: $keyCode, device id: $deviceId, meta state: $metaState, scan code: $scanCode")
 
@@ -217,15 +224,9 @@ class DetectKeyMapsUseCaseImpl(
 
                 KeyEvent.KEYCODE_MENU -> openMenuHelper.openMenu()
 
-                else -> imeInputEventInjector.inputKeyEvent(
-                    InputKeyModel(
-                        keyCode,
-                        inputEventType,
-                        metaState,
-                        deviceId,
-                        scanCode,
-                    ),
-                )
+                else -> runBlocking {
+                    imeInputEventInjector.inputKeyEvent(model)
+                }
             }
         }
     }