From 19005e69971193bd6b30669ca0a38fd48803bb39 Mon Sep 17 00:00:00 2001 From: WhiredPlanck Date: Wed, 16 Oct 2024 01:08:35 +0800 Subject: [PATCH] feat: implement RimeEvent to hold events created by this frontend feat: forward rejected key event via callback flow to handle globally --- .../main/java/com/osfans/trime/core/Rime.kt | 51 +++++++++++++++---- .../java/com/osfans/trime/core/RimeEvent.kt | 37 ++++++++++++++ .../trime/ime/core/TrimeInputMethodService.kt | 48 ++++++++--------- 3 files changed, 100 insertions(+), 36 deletions(-) create mode 100644 app/src/main/java/com/osfans/trime/core/RimeEvent.kt diff --git a/app/src/main/java/com/osfans/trime/core/Rime.kt b/app/src/main/java/com/osfans/trime/core/Rime.kt index af316c5565..35992361a3 100644 --- a/app/src/main/java/com/osfans/trime/core/Rime.kt +++ b/app/src/main/java/com/osfans/trime/core/Rime.kt @@ -79,7 +79,13 @@ class Rime : modifiers: UInt, ): Boolean = withRimeContext { - processRimeKey(value, modifiers.toInt()).also { if (it) requestRimeResponse() } + processRimeKey(value, modifiers.toInt()).also { + if (it) { + requestRimeResponse() + } else { + keyEventCallback(KeyValue(value), KeyModifiers(modifiers)) + } + } } override suspend fun processKey( @@ -87,7 +93,13 @@ class Rime : modifiers: KeyModifiers, ): Boolean = withRimeContext { - processRimeKey(value.value, modifiers.toInt()).also { if (it) requestRimeResponse() } + processRimeKey(value.value, modifiers.toInt()).also { + if (it) { + requestRimeResponse() + } else { + keyEventCallback(value, modifiers) + } + } } override suspend fun selectCandidate(idx: Int): Boolean = @@ -286,7 +298,11 @@ class Rime : Timber.d("processKey: keyCode=$keycode, mask=$mask") return processRimeKey(keycode, mask).also { Timber.d("processKey ${if (it) "success" else "failed"}") - if (it) requestRimeResponse() + if (it) { + requestRimeResponse() + } else { + keyEventCallback(KeyValue(keycode), KeyModifiers.of(mask)) + } } } @@ -482,6 +498,29 @@ class Rime : callbackFlow_.tryEmit(notification) } + fun requestRimeResponse() { + val response = RimeResponse(getRimeCommit(), getRimeContext(), getRimeStatus()) + Timber.d("Got Rime response: $response") + callbackFlow_.tryEmit(response) + } + + private fun keyEventCallback( + value: KeyValue, + modifiers: KeyModifiers, + ) { + handleRimeEvent(RimeEvent.EventType.Key, RimeEvent.KeyEvent.Data(value, modifiers)) + } + + private fun handleRimeEvent( + type: RimeEvent.EventType, + data: T, + ) { + val event = RimeEvent.create(type, data) + Timber.d("Handling $event") + callbackHandlers.forEach { it.invoke(event) } + callbackFlow_.tryEmit(event) + } + private fun registerRimeCallbackHandler(handler: (RimeCallback) -> Unit) { if (callbackHandlers.contains(handler)) return callbackHandlers.add(handler) @@ -490,11 +529,5 @@ class Rime : private fun unregisterRimeCallbackHandler(handler: (RimeCallback) -> Unit) { callbackHandlers.remove(handler) } - - fun requestRimeResponse() { - val response = RimeResponse(getRimeCommit(), getRimeContext(), getRimeStatus()) - Timber.d("Got Rime response: $response") - callbackFlow_.tryEmit(response) - } } } diff --git a/app/src/main/java/com/osfans/trime/core/RimeEvent.kt b/app/src/main/java/com/osfans/trime/core/RimeEvent.kt new file mode 100644 index 0000000000..67e628c342 --- /dev/null +++ b/app/src/main/java/com/osfans/trime/core/RimeEvent.kt @@ -0,0 +1,37 @@ +/* + * SPDX-FileCopyrightText: 2015 - 2024 Rime community + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +package com.osfans.trime.core + +sealed class RimeEvent( + open val data: T, +) : RimeCallback { + abstract val eventType: EventType + + data class KeyEvent( + override val data: Data, + ) : RimeEvent(data) { + override val eventType = EventType.Key + + data class Data( + val value: KeyValue, + val modifiers: KeyModifiers, + ) + } + + enum class EventType { + Key, + } + + companion object { + fun create( + type: EventType, + data: T, + ) = when (type) { + EventType.Key -> + KeyEvent(data as KeyEvent.Data) + } + } +} 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 index b4c7b232fe..8262cd56fb 100644 --- a/app/src/main/java/com/osfans/trime/ime/core/TrimeInputMethodService.kt +++ b/app/src/main/java/com/osfans/trime/ime/core/TrimeInputMethodService.kt @@ -38,6 +38,7 @@ import com.osfans.trime.core.KeyValue import com.osfans.trime.core.Rime import com.osfans.trime.core.RimeApi import com.osfans.trime.core.RimeCallback +import com.osfans.trime.core.RimeEvent import com.osfans.trime.core.RimeKeyMapping import com.osfans.trime.core.RimeNotification import com.osfans.trime.core.RimeProto @@ -294,6 +295,24 @@ open class TrimeInputMethodService : LifecycleInputMethodService() { } updateComposing() } + is RimeEvent.KeyEvent -> + it.data.let event@{ + val keyCode = it.value.keyCode + if (keyCode != KeyEvent.KEYCODE_UNKNOWN) { + val eventTime = SystemClock.uptimeMillis() + if (it.modifiers.modifiers == KeyModifier.Release.modifier) { + sendUpKeyEvent(eventTime, keyCode, it.modifiers.metaState) + } else { + sendDownKeyEvent(eventTime, keyCode, it.modifiers.metaState) + } + } else { + if (it.modifiers.modifiers != KeyModifier.Release.modifier && it.value.value > 0) { + commitText(Char(it.value.value).toString()) + } else { + Timber.w("Unhandled Rime KeyEvent: $it") + } + } + } else -> {} } } @@ -772,18 +791,14 @@ open class TrimeInputMethodService : LifecycleInputMethodService() { val charCode = event.unicodeChar if (charCode > 0 && charCode != '\t'.code) { postRimeJob { - if (!processKey(charCode, modifiers.modifiers)) { - onKeyEventCallback(KeyValue(charCode), modifiers) - } + processKey(charCode, modifiers.modifiers) } return true } val keyVal = KeyValue.fromKeyEvent(event) if (keyVal.value != RimeKeyMapping.RimeKey_VoidSymbol) { postRimeJob { - if (!processKey(keyVal, modifiers)) { - onKeyEventCallback(keyVal, modifiers) - } + processKey(keyVal, modifiers) } return true } @@ -791,27 +806,6 @@ open class TrimeInputMethodService : LifecycleInputMethodService() { return false } - private fun onKeyEventCallback( - keyVal: KeyValue, - modifiers: KeyModifiers, - ) { - val keyCode = keyVal.keyCode - if (keyCode != KeyEvent.KEYCODE_UNKNOWN) { - val eventTime = SystemClock.uptimeMillis() - if (modifiers.modifiers == KeyModifier.Release.modifier) { - sendUpKeyEvent(eventTime, keyCode, modifiers.metaState) - } else { - sendDownKeyEvent(eventTime, keyCode, modifiers.metaState) - } - } else { - if (modifiers.modifiers != KeyModifier.Release.modifier && keyVal.value > 0) { - commitText(Char(keyVal.value).toString()) - } else { - Timber.w("Unhandled Rime KeyEvent: ($keyVal, $modifiers)") - } - } - } - override fun onKeyDown( keyCode: Int, event: KeyEvent,