refactor: tell key processing API if the system key event is ACTION_UP

osfans · Nov 10, 2024 · 2c9cbfb · 2c9cbfb
1 parent c940750
commit 2c9cbfb
Show file tree

Hide file tree

Showing 5 changed files with 21 additions and 17 deletions.
diff --git a/app/src/main/java/com/osfans/trime/core/KeyModifier.kt b/app/src/main/java/com/osfans/trime/core/KeyModifier.kt
@@ -85,15 +85,12 @@ value class KeyModifiers(
         fun fromKeyEvent(event: KeyEvent): KeyModifiers {
             var states = KeyModifier.None.modifier
             event.apply {
-                if (action == KeyEvent.ACTION_UP) {
-                    states += KeyModifier.Release
-                } else {
-                    if (isAltPressed) states += KeyModifier.Alt
-                    if (isCtrlPressed) states += KeyModifier.Control
-                    if (isShiftPressed) states += KeyModifier.Shift
-                    if (isCapsLockOn) states += KeyModifier.Lock
-                    if (isMetaPressed) states += KeyModifier.Meta
-                }
+                if (isAltPressed) states += KeyModifier.Alt
+                if (isCtrlPressed) states += KeyModifier.Control
+                if (isShiftPressed) states += KeyModifier.Shift
+                if (isCapsLockOn) states += KeyModifier.Lock
+                if (isMetaPressed) states += KeyModifier.Meta
+                if (action == KeyEvent.ACTION_UP) states += KeyModifier.Release
             }
             return KeyModifiers(states)
         }

diff --git a/app/src/main/java/com/osfans/trime/core/Rime.kt b/app/src/main/java/com/osfans/trime/core/Rime.kt
@@ -78,13 +78,14 @@ class Rime :
         value: Int,
         modifiers: UInt,
         code: Int,
+        up: Boolean,
     ): Boolean =
         withRimeContext {
             processRimeKey(value, modifiers.toInt()).also {
                 if (it) {
                     ipcResponseCallback()
                 } else {
-                    keyEventCallback(KeyValue(value), KeyModifiers(modifiers), code)
+                    keyEventCallback(KeyValue(value), KeyModifiers(modifiers), code, up)
                 }
             }
         }
@@ -93,13 +94,14 @@ class Rime :
         value: KeyValue,
         modifiers: KeyModifiers,
         code: Int,
+        up: Boolean,
     ): Boolean =
         withRimeContext {
             processRimeKey(value.value, modifiers.toInt()).also {
                 if (it) {
                     ipcResponseCallback()
                 } else {
-                    keyEventCallback(value, modifiers, code)
+                    keyEventCallback(value, modifiers, code, up)
                 }
             }
         }
@@ -453,8 +455,9 @@ class Rime :
             value: KeyValue,
             modifiers: KeyModifiers,
             code: Int,
+            up: Boolean,
         ) {
-            handleRimeEvent(RimeEvent.EventType.Key, RimeEvent.KeyEvent.Data(value, modifiers, code))
+            handleRimeEvent(RimeEvent.EventType.Key, RimeEvent.KeyEvent.Data(value, modifiers, code, up))
         }
 
         private fun <T> handleRimeEvent(

diff --git a/app/src/main/java/com/osfans/trime/core/RimeApi.kt b/app/src/main/java/com/osfans/trime/core/RimeApi.kt
@@ -23,12 +23,14 @@ interface RimeApi {
         value: Int,
         modifiers: UInt = 0u,
         code: Int = 0,
+        up: Boolean = false,
     ): Boolean
 
     suspend fun processKey(
         value: KeyValue,
         modifiers: KeyModifiers,
         code: Int = 0,
+        up: Boolean = false,
     ): Boolean
 
     suspend fun selectCandidate(idx: Int): Boolean

diff --git a/app/src/main/java/com/osfans/trime/core/RimeEvent.kt b/app/src/main/java/com/osfans/trime/core/RimeEvent.kt
@@ -31,6 +31,7 @@ sealed class RimeEvent<T>(
             val value: KeyValue,
             val modifiers: KeyModifiers,
             val unicode: Int,
+            val up: Boolean,
         )
     }
 

diff --git a/app/src/main/java/com/osfans/trime/ime/core/TrimeInputMethodService.kt b/app/src/main/java/com/osfans/trime/ime/core/TrimeInputMethodService.kt
@@ -16,6 +16,7 @@ import android.text.InputType
 import android.view.InputDevice
 import android.view.KeyCharacterMap
 import android.view.KeyEvent
+import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import android.view.Window
@@ -32,7 +33,6 @@ import androidx.core.view.updateLayoutParams
 import androidx.lifecycle.lifecycleScope
 import com.osfans.trime.BuildConfig
 import com.osfans.trime.R
-import com.osfans.trime.core.KeyModifier
 import com.osfans.trime.core.KeyModifiers
 import com.osfans.trime.core.KeyValue
 import com.osfans.trime.core.Rime
@@ -297,13 +297,13 @@ open class TrimeInputMethodService : LifecycleInputMethodService() {
                     val keyCode = it.value.keyCode
                     if (keyCode != KeyEvent.KEYCODE_UNKNOWN) {
                         val eventTime = SystemClock.uptimeMillis()
-                        if (it.modifiers.modifiers == KeyModifier.Release.modifier) {
+                        if (it.up) {
                             sendUpKeyEvent(eventTime, keyCode, it.modifiers.metaState)
                         } else {
                             sendDownKeyEvent(eventTime, keyCode, it.modifiers.metaState)
                         }
                     } else {
-                        if (it.modifiers.modifiers != KeyModifier.Release.modifier && it.unicode > 0) {
+                        if (!it.up && it.unicode > 0) {
                             commitText(Char(it.unicode).toString())
                         } else {
                             Timber.w("Unhandled Rime KeyEvent: $it")
@@ -764,18 +764,19 @@ open class TrimeInputMethodService : LifecycleInputMethodService() {
     }
 
     private fun forwardKeyEvent(event: KeyEvent): Boolean {
+        val up = event.action == MotionEvent.ACTION_UP
         val modifiers = KeyModifiers.fromKeyEvent(event)
         val charCode = event.unicodeChar
         if (charCode > 0 && charCode != '\t'.code) {
             postRimeJob {
-                processKey(charCode, modifiers.modifiers, event.scanCode)
+                processKey(charCode, modifiers.modifiers, event.scanCode, up)
             }
             return true
         }
         val keyVal = KeyValue.fromKeyEvent(event)
         if (keyVal.value != RimeKeyMapping.RimeKey_VoidSymbol) {
             postRimeJob {
-                processKey(keyVal, modifiers, event.scanCode)
+                processKey(keyVal, modifiers, event.scanCode, up)
             }
             return true
         }