refactor: replace handler with main looper with custom RimeLifecycleScope

Author: WhiredPlanck

app/src/main/java/com/osfans/trime/TrimeApplication.kt

@@ -10,6 +10,9 @@ import com.osfans.trime.data.db.ClipboardHelper
 import com.osfans.trime.data.db.CollectionHelper
 import com.osfans.trime.data.db.DraftHelper
 import com.osfans.trime.ui.main.LogActivity
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.plus
 import timber.log.Timber
 import kotlin.system.exitProcess
 
@@ -31,6 +34,8 @@ class TrimeApplication : Application() {
         private const val MAX_STACKTRACE_SIZE = 128000
     }
 
+    val coroutineScope = MainScope() + CoroutineName("TrimeApplication")
+
     override fun onCreate() {
         super.onCreate()
         if (!BuildConfig.DEBUG) {

app/src/main/java/com/osfans/trime/core/RimeLifecycle.kt

@@ -1,23 +1,24 @@
+// Adapted from https://github.com/fcitx5-android/fcitx5-android/blob/364afb44dcf0d9e3db3d43a21a32601b2190cbdf/app/src/main/java/org/fcitx/fcitx5/android/core/FcitxLifecycle.kt
 package com.osfans.trime.core
 
-import android.os.Handler
-import android.os.Looper
-import androidx.core.os.HandlerCompat
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancelChildren
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
-import java.util.Collections
+import kotlinx.coroutines.launch
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 class RimeLifecycleImpl : RimeLifecycle {
     private val _stateFlow = MutableStateFlow(RimeLifecycle.State.STOPPED)
     override val stateFlow = _stateFlow.asStateFlow()
 
-    override val handler = HandlerCompat.createAsync(Looper.getMainLooper())
-    override val runnableList: MutableList<Runnable> = Collections.synchronizedList(mutableListOf<Runnable>())
+    override val lifecycleScope: CoroutineScope = RimeLifecycleScope(this)
 
     fun emitState(state: RimeLifecycle.State) {
         when (state) {
@@ -43,8 +44,7 @@ class RimeLifecycleImpl : RimeLifecycle {
 
 interface RimeLifecycle {
     val stateFlow: StateFlow<State>
-    val handler: Handler
-    val runnableList: MutableList<Runnable>
+    val lifecycleScope: CoroutineScope
 
     enum class State {
         STARTING,
@@ -55,40 +55,59 @@ interface RimeLifecycle {
 
 interface RimeLifecycleOwner {
     val lifecycle: RimeLifecycle
-    val handler get() = lifecycle.handler
 }
 
-fun RimeLifecycle.whenAtState(
+val RimeLifecycleOwner.lifecycleScope get() = lifecycle.lifecycleScope
+
+class RimeLifecycleScope(
+    val lifecycle: RimeLifecycle,
+    override val coroutineContext: CoroutineContext = SupervisorJob(),
+) : CoroutineScope {
+    init {
+        launch {
+            lifecycle.stateFlow.collect {
+                if (it == RimeLifecycle.State.STOPPED) {
+                    coroutineContext.cancelChildren()
+                }
+            }
+        }
+    }
+}
+
+suspend fun <T> RimeLifecycle.whenAtState(
     state: RimeLifecycle.State,
-    block: () -> Unit,
-) {
-    runnableList.add(Runnable { block() })
-    if (stateFlow.value == state) {
-        handler.post(runnableList.removeFirst())
+    block: suspend CoroutineScope.() -> T,
+): T {
+    return if (stateFlow.value == state) {
+        block(lifecycleScope)
     } else {
         StateDelegate(this, state).run(block)
     }
 }
 
-inline fun RimeLifecycle.whenReady(noinline block: () -> Unit) = whenAtState(RimeLifecycle.State.READY, block)
+suspend inline fun <T> RimeLifecycle.whenReady(noinline block: suspend CoroutineScope.() -> T) =
+    whenAtState(RimeLifecycle.State.READY, block)
 
 private class StateDelegate(val lifecycle: RimeLifecycle, val state: RimeLifecycle.State) {
     private var job: Job? = null
 
     init {
         job =
-            lifecycle.stateFlow.onEach {
-                if (it == state) {
-                    while (lifecycle.runnableList.isNotEmpty()) {
-                        lifecycle.handler.post(lifecycle.runnableList.removeFirst())
+            lifecycle.lifecycleScope.launch {
+                lifecycle.stateFlow.collect {
+                    if (it == state) {
+                        continuation?.resume(Unit)
                     }
                 }
-            }.launchIn(MainScope())
+            }
     }
 
-    fun <T> run(block: () -> T): T {
+    private var continuation: Continuation<Unit>? = null
+
+    suspend fun <T> run(block: suspend CoroutineScope.() -> T): T {
+        suspendCoroutine { continuation = it }
         job?.cancel()
         job = null
-        return block()
+        return block(lifecycle.lifecycleScope)
     }
 }

app/src/main/java/com/osfans/trime/daemon/RimeDaemon.kt

@@ -3,16 +3,34 @@ package com.osfans.trime.daemon
 import androidx.core.app.NotificationCompat
 import com.blankj.utilcode.util.NotificationUtils
 import com.osfans.trime.R
+import com.osfans.trime.TrimeApplication
 import com.osfans.trime.core.Rime
 import com.osfans.trime.core.RimeApi
 import com.osfans.trime.core.RimeLifecycle
+import com.osfans.trime.core.lifecycleScope
 import com.osfans.trime.core.whenReady
 import com.osfans.trime.util.appContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import splitties.systemservices.notificationManager
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
+/**
+ * Manage the singleton instance of [Rime]
+ *
+ * To use rime, client should call [createSession] to obtain a [RimeSession],
+ * and call [destroySession] on client destroyed. Client should not leak the instance of [RimeApi],
+ * and must use [RimeSession] to access rime functionalities.
+ *
+ * The instance of [Rime] always exists,but whether the dispatcher runs and callback works depend on clients, i.e.
+ * if no clients are connected, [Rime.finalize] will be called.
+ *
+ * Functions are thread-safe in this class.
+ *
+ * Adapted from [fcitx5-android/FcitxDaemon.kt](https://github.com/fcitx5-android/fcitx5-android/blob/364afb44dcf0d9e3db3d43a21a32601b2190cbdf/app/src/main/java/org/fcitx/fcitx5/android/daemon/FcitxDaemon.kt)
+ */
 object RimeDaemon {
     private val realRime by lazy { Rime() }
 
@@ -36,19 +54,23 @@ object RimeDaemon {
                     runBlocking { block(rimeImpl) }
                 }
 
-            override fun runOnReady(block: RimeApi.() -> Unit) {
+            override suspend fun <T> runOnReady(block: suspend RimeApi.() -> T): T =
                 ensureEstablished {
                     realRime.lifecycle.whenReady { block(rimeImpl) }
                 }
-            }
 
-            override fun runIfReady(block: RimeApi.() -> Unit) {
+            override fun runIfReady(block: suspend RimeApi.() -> Unit) {
                 ensureEstablished {
                     if (realRime.isReady) {
-                        realRime.lifecycle.handler.post { block(rimeImpl) }
+                        realRime.lifecycleScope.launch {
+                            block(rimeImpl)
+                        }
                     }
                 }
             }
+
+            override val lifecycleScope: CoroutineScope
+                get() = realRime.lifecycle.lifecycleScope
         }
 
     fun createSession(name: String): RimeSession =
@@ -94,9 +116,11 @@ object RimeDaemon {
             }
             realRime.finalize()
             realRime.startup(fullCheck)
-            // cancel notification on ready
-            realRime.lifecycle.whenReady {
-                notificationManager.cancel(CHANNEL_ID, id)
+            TrimeApplication.getInstance().coroutineScope.launch {
+                // cancel notification on ready
+                realRime.lifecycle.whenReady {
+                    notificationManager.cancel(CHANNEL_ID, id)
+                }
             }
         }
 }

app/src/main/java/com/osfans/trime/daemon/RimeSession.kt

@@ -1,6 +1,7 @@
 package com.osfans.trime.daemon
 
 import com.osfans.trime.core.RimeApi
+import kotlinx.coroutines.CoroutineScope
 
 /**
  * A interface to run different operations on RimeApi
@@ -17,15 +18,18 @@ interface RimeSession {
     /**
      * Run an operation immediately if rime is at ready state.
      * Otherwise, caller will be suspended until rime is ready and operation is done.
-     * The [block] will be executed in main thread.
+     * The [block] will be executed in caller's thread.
      * Client should use this function in most cases.
      */
-    fun runOnReady(block: RimeApi.() -> Unit)
+    suspend fun <T> runOnReady(block: suspend RimeApi.() -> T): T
 
     /**
      * Run an operation if rime is at ready state.
      * Otherwise, do nothing.
-     * The [block] will be executed in main thread.
+     * The [block] will be executed in executed in thread pool.
+     * This function does not block or suspend the caller.
      */
-    fun runIfReady(block: RimeApi.() -> Unit)
+    fun runIfReady(block: suspend RimeApi.() -> Unit)
+
+    val lifecycleScope: CoroutineScope
 }