Load Rime in Background Thread

app/src/main/java/com/osfans/trime/data/AppPrefs.kt

@@ -333,14 +333,15 @@ class AppPrefs(
             const val TIMING_SYNC_TRIGGER_TIME = "profile_timing_sync_trigger_time"
             const val LAST_SYNC_STATUS = "profile_last_sync_status"
             const val LAST_BACKGROUND_SYNC = "profile_last_background_sync"
-            val EXTERNAL_PATH_PREFIX: String = PathUtils.getExternalStoragePath()
+
+            private fun getExternalPathPrefix() = PathUtils.getExternalStoragePath()
         }
 
         var sharedDataDir: String
-            get() = prefs.getPref(SHARED_DATA_DIR, "$EXTERNAL_PATH_PREFIX/rime")
+            get() = prefs.getPref(SHARED_DATA_DIR, "${getExternalPathPrefix()}/rime")
             set(v) = prefs.setPref(SHARED_DATA_DIR, v)
         var userDataDir: String
-            get() = prefs.getPref(USER_DATA_DIR, "$EXTERNAL_PATH_PREFIX/rime")
+            get() = prefs.getPref(USER_DATA_DIR, "${getExternalPathPrefix()}/rime")
             set(v) = prefs.setPref(USER_DATA_DIR, v)
         var syncBackgroundEnabled: Boolean
             get() = prefs.getPref(SYNC_BACKGROUND_ENABLED, false)

app/src/main/java/com/osfans/trime/data/DataManager.kt

@@ -6,24 +6,19 @@ import com.osfans.trime.util.Const
 import timber.log.Timber
 import java.io.File
 
-object DataManager : DataDirectoryChangeListener.Listener {
+object DataManager {
+    private const val DEFAULT_CUSTOM_FILE_NAME = "default.custom.yaml"
     private val prefs get() = AppPrefs.defaultInstance()
 
     val defaultDataDirectory = File(PathUtils.getExternalStoragePath(), "rime")
 
     @JvmStatic
-    var sharedDataDir = File(prefs.profile.sharedDataDir)
+    val sharedDataDir
+        get() = File(prefs.profile.sharedDataDir)
 
     @JvmStatic
-    var userDataDir = File(prefs.profile.userDataDir)
-    val customDefault = File(sharedDataDir, "default.custom.yaml")
-
-    private val stagingDir = File(userDataDir, "build")
-    private val prebuiltDataDir = File(sharedDataDir, "build")
-
-    init {
-        DataDirectoryChangeListener.addDirectoryChangeListener(this)
-    }
+    val userDataDir
+        get() = File(prefs.profile.userDataDir)
 
     sealed class Diff {
         object New : Diff()
@@ -42,6 +37,9 @@ object DataManager : DataDirectoryChangeListener.Listener {
      */
     @JvmStatic
     fun resolveDeployedResourcePath(resourceId: String): String {
+        val stagingDir = File(userDataDir, "build")
+        val prebuiltDataDir = File(sharedDataDir, "build")
+
         val defaultPath = File(stagingDir, "$resourceId.yaml")
         if (!defaultPath.exists()) {
             val fallbackPath = File(prebuiltDataDir, "$resourceId.yaml")
@@ -84,19 +82,14 @@ object DataManager : DataDirectoryChangeListener.Listener {
         }
 
         // FIXME：缺失 default.custom.yaml 会导致方案列表为空
-        if (!customDefault.exists()) {
-            Timber.d("Creating empty default.custom.yaml ...")
-            customDefault.createNewFile()
+        with(File(sharedDataDir, DEFAULT_CUSTOM_FILE_NAME)) {
+            val customDefault = this
+            if (!customDefault.exists()) {
+                Timber.d("Creating empty default.custom.yaml ...")
+                customDefault.createNewFile()
+            }
         }
 
         Timber.i("Synced!")
     }
-
-    /**
-     * Update sharedDataDir and userDataDir.
-     */
-    override fun onDataDirectoryChange() {
-        sharedDataDir = File(prefs.profile.sharedDataDir)
-        userDataDir = File(prefs.profile.userDataDir)
-    }
 }

app/src/main/java/com/osfans/trime/data/theme/FontManager.kt

@@ -5,10 +5,10 @@ import com.osfans.trime.data.DataManager
 import java.io.File
 
 object FontManager {
-    val fontDir = File(DataManager.userDataDir, "fonts")
-
     @JvmStatic
     fun getTypeface(fontFileName: String): Typeface {
+        val fontDir = File(DataManager.userDataDir, "fonts")
+
         val f = File(fontDir, fontFileName)
         return if (f.exists()) {
             Typeface.createFromFile(f)

app/src/main/java/com/osfans/trime/data/theme/Theme.kt

@@ -22,7 +22,6 @@ import android.graphics.drawable.GradientDrawable
 import androidx.core.math.MathUtils
 import com.osfans.trime.core.Rime
 import com.osfans.trime.data.AppPrefs
-import com.osfans.trime.data.DataManager.sharedDataDir
 import com.osfans.trime.data.DataManager.userDataDir
 import com.osfans.trime.data.schema.SchemaManager
 import com.osfans.trime.data.sound.SoundThemeManager
@@ -87,7 +86,6 @@ class Theme private constructor(isDarkMode: Boolean) {
     init {
         self = this
         ThemeManager.init()
-        Rime.getInstance(!sharedDataDir.exists())
         init(isDarkMode)
         Timber.d("Setting sound from color ...")
         SoundThemeManager.switchSound(colors.getString("sound"))
@@ -303,6 +301,8 @@ class Theme private constructor(isDarkMode: Boolean) {
                         ?: throw IllegalStateException("The default keyboard definition is missing!")
                 if (defaultMap.containsKey("import_preset")) {
                     return defaultMap["import_preset"] as? String ?: "default"
+                } else {
+                    return "default"
                 }
             }
             return remapped

app/src/main/java/com/osfans/trime/ime/broadcast/IntentReceiver.kt

@@ -32,6 +32,7 @@ import com.blankj.utilcode.util.ToastUtils
 import com.osfans.trime.R
 import com.osfans.trime.core.Rime
 import com.osfans.trime.data.AppPrefs
+import com.osfans.trime.ime.core.RimeWrapper
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.MainScope
@@ -54,14 +55,14 @@ class IntentReceiver : BroadcastReceiver(), CoroutineScope by MainScope() {
             COMMAND_DEPLOY ->
                 launch {
                     withContext(Dispatchers.Default) {
-                        Rime.deploy()
+                        RimeWrapper.deploy()
                     }
                     ToastUtils.showLong(R.string.deploy_finish)
                 }
             COMMAND_SYNC ->
                 async {
                     Rime.syncRimeUserData()
-                    Rime.deploy()
+                    RimeWrapper.deploy()
                 }
             COMMAND_TIMING_SYNC ->
                 async {
@@ -96,7 +97,7 @@ class IntentReceiver : BroadcastReceiver(), CoroutineScope by MainScope() {
                         alarmManager.setExact(AlarmManager.RTC_WAKEUP, triggerTime, pendingIntent)
                     }
                     Rime.syncRimeUserData()
-                    Rime.deploy()
+                    RimeWrapper.deploy()
                     wakeLock.release() // 释放唤醒锁
                 }
             else -> return

app/src/main/java/com/osfans/trime/ime/core/RimeWrapper.kt

@@ -0,0 +1,121 @@
+package com.osfans.trime.ime.core
+
+import android.os.Looper
+import androidx.core.os.HandlerCompat
+import com.osfans.trime.core.Rime
+import com.osfans.trime.data.DataDirectoryChangeListener
+import com.osfans.trime.data.theme.Theme
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Runnable
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import timber.log.Timber
+import java.util.Collections
+import kotlin.system.measureTimeMillis
+
+object RimeWrapper {
+    private var mainThreadHandler = HandlerCompat.createAsync(Looper.getMainLooper())
+    private val mutex = Mutex()
+    private val myThreadSafeList = Collections.synchronizedList(mutableListOf<Runnable>())
+    private val _statusStateFlow = MutableStateFlow(Status.UN_INIT)
+    val statusStateFlow = _statusStateFlow.asStateFlow()
+
+    var canStart = false
+
+    fun startup(r: Runnable? = null) {
+        r.let {
+            myThreadSafeList.add(it)
+        }
+        if (canStart) {
+            if (mutex.tryLock()) {
+                if (_statusStateFlow.value == Status.UN_INIT) {
+                    Timber.d("Starting in a thread")
+                    _statusStateFlow.value = Status.IN_PROGRESS
+                    mutex.unlock()
+
+                    val scope = CoroutineScope(Dispatchers.IO)
+                    scope.launch {
+                        measureTimeMillis {
+                            Rime.getInstance(false)
+                            Theme.get()
+                        }.also {
+                            Timber.d("Startup completed.  It takes ${it / 1000} seconds")
+                        }
+
+                        mutex.withLock {
+                            _statusStateFlow.value = Status.READY
+                        }
+
+                        notifyUnlock()
+                    }
+                } else {
+                    mutex.unlock()
+                }
+            }
+        } else {
+            Timber.d("RimeWrapper shall not be started")
+        }
+    }
+
+    suspend fun deploy(): Boolean {
+        if (mutex.tryLock()) {
+            if (_statusStateFlow.value != Status.IN_PROGRESS) {
+                _statusStateFlow.value = Status.IN_PROGRESS
+                mutex.unlock()
+
+                DataDirectoryChangeListener.directoryChangeListeners.forEach {
+                    it.onDataDirectoryChange()
+                }
+
+                Rime.deploy()
+
+                mutex.withLock {
+                    _statusStateFlow.value = Status.READY
+                }
+                Timber.d("Rime Deployed")
+
+                return true
+            } else {
+                mutex.unlock()
+            }
+        }
+        return false
+    }
+
+    private fun notifyUnlock() {
+        Timber.d("notifying unlock")
+        while (myThreadSafeList.isNotEmpty()) {
+            myThreadSafeList.removeFirstOrNull()?.let {
+                mainThreadHandler.post(it)
+            }
+        }
+        Timber.d("Unlock Run Completed")
+    }
+
+    fun runCheck() {
+        if (isReady()) {
+            notifyUnlock()
+        } else if (_statusStateFlow.value == Status.UN_INIT) {
+            startup()
+        }
+    }
+
+    fun isReady(): Boolean {
+        return _statusStateFlow.value == Status.READY
+    }
+
+    fun runAfterStarted(r: Runnable) {
+        myThreadSafeList.add(r)
+        runCheck()
+    }
+}
+
+enum class Status {
+    UN_INIT,
+    IN_PROGRESS,
+    READY,
+}