feat: add wrapper of native config parser

WhiredPlanck · WhiredPlanck · commit 582b474d2403 · 2025-06-18T19:07:39.000+08:00
diff --git a/app/src/main/java/com/osfans/trime/core/RimeConfig.kt b/app/src/main/java/com/osfans/trime/core/RimeConfig.kt
@@ -0,0 +1,140 @@
+/*
+ * SPDX-FileCopyrightText: 2015 - 2025 Rime community
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+package com.osfans.trime.core
+
+class RimeConfig private constructor(
+    private val ptr: Long,
+) : AutoCloseable {
+    fun getString(
+        key: String,
+        defaultValue: String = "",
+    ): String {
+        check(ptr != 0L)
+        return getRimeConfigString(ptr, key) ?: defaultValue
+    }
+
+    fun getBool(
+        key: String,
+        defaultValue: Boolean = false,
+    ): Boolean {
+        check(ptr != 0L)
+        return getRimeConfigBool(ptr, key) ?: defaultValue
+    }
+
+    fun getDouble(
+        key: String,
+        defaultValue: Double = 0.0,
+    ): Double {
+        check(ptr != 0L)
+        return getRimeConfigDouble(ptr, key) ?: defaultValue
+    }
+
+    fun getInt(
+        key: String,
+        defaultValue: Int = 0,
+    ): Int {
+        check(ptr != 0L)
+        return getRimeConfigInt(ptr, key) ?: defaultValue
+    }
+
+    fun getList(key: String): List<RimeConfig> {
+        check(ptr != 0L)
+        val array = getRimeConfigList(ptr, key) ?: return emptyList()
+        return array.map { RimeConfig(it) }
+    }
+
+    fun getStringList(key: String): List<String> {
+        check(ptr != 0L)
+        return getRimeConfigList(ptr, key)?.map {
+            getRimeConfigString(it, "") ?: ""
+        } ?: emptyList()
+    }
+
+    fun getMap(key: String): Map<String, RimeConfig> {
+        check(ptr != 0L)
+        val map = getRimeConfigMap(ptr, key) ?: return emptyMap()
+        return map.mapValues { RimeConfig(it.value) }
+    }
+
+    fun getStringValueMap(key: String): Map<String, String> {
+        check(ptr != 0L)
+        val map = getRimeConfigMap(ptr, key) ?: return emptyMap()
+        return map.mapValues { getRimeConfigString(ptr, key) ?: "" }
+    }
+
+    fun getItem(key: String): RimeConfig {
+        check(ptr != 0L)
+        return RimeConfig(getRimeConfigItem(ptr, key))
+    }
+
+    override fun close() {
+        if (ptr != 0L) {
+            closeRimeConfig(ptr)
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        private external fun openRimeSchema(schemaId: String): Long
+
+        @JvmStatic
+        private external fun openRimeConfig(configId: String): Long
+
+        @JvmStatic
+        private external fun openRimeUserConfig(configId: String): Long
+
+        @JvmStatic
+        private external fun getRimeConfigString(
+            ptr: Long,
+            key: String,
+        ): String?
+
+        @JvmStatic
+        private external fun getRimeConfigBool(
+            ptr: Long,
+            key: String,
+        ): Boolean?
+
+        @JvmStatic
+        private external fun getRimeConfigDouble(
+            ptr: Long,
+            key: String,
+        ): Double?
+
+        @JvmStatic
+        private external fun getRimeConfigInt(
+            ptr: Long,
+            key: String,
+        ): Int?
+
+        @JvmStatic
+        private external fun getRimeConfigList(
+            ptr: Long,
+            key: String,
+        ): LongArray?
+
+        @JvmStatic
+        private external fun getRimeConfigMap(
+            ptr: Long,
+            key: String,
+        ): Map<String, Long>?
+
+        @JvmStatic
+        private external fun getRimeConfigItem(
+            ptr: Long,
+            key: String,
+        ): Long
+
+        @JvmStatic
+        private external fun closeRimeConfig(ptr: Long)
+
+        fun openSchema(schemaId: String) = RimeConfig(openRimeSchema(schemaId))
+
+        fun openConfig(configId: String) = RimeConfig(openRimeConfig(configId))
+
+        fun openUserConfig(configId: String) = RimeConfig(openRimeUserConfig(configId))
+    }
+}
diff --git a/app/src/main/java/com/osfans/trime/data/base/DataManager.kt b/app/src/main/java/com/osfans/trime/data/base/DataManager.kt
@@ -53,6 +53,9 @@ object DataManager {
     val userDataDir
         get() = File(prefs.profile.userDataDir).also { it.mkdirs() }
 
+    val prebuiltDataDir = File(sharedDataDir, "build")
+    val stagingDir get() = File(userDataDir, "build")
+
     /**
      * Return the absolute path of the compiled config file
      * based on given resource id.
@@ -62,9 +65,6 @@ object DataManager {
      */
     @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")
diff --git a/app/src/main/java/com/osfans/trime/data/schema/Schema.kt b/app/src/main/java/com/osfans/trime/data/schema/Schema.kt
@@ -4,34 +4,44 @@
 
 package com.osfans.trime.data.schema
 
-import com.osfans.trime.util.config.Config
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.Transient
+import com.osfans.trime.core.RimeConfig
+import timber.log.Timber
 
 class Schema(
-    schemaId: String = ".default",
+    schemaId: String,
 ) {
-    private val config =
-        if (schemaId == ".default") {
-            Config.create("default")
-        } else {
-            Config.create("$schemaId.schema")
-        }
+    val switches: List<Switch>
 
-    val switches get() =
-        config?.getList("switches")
+    val symbols: Map<String, RimeConfig>
 
-    val symbols get() =
-        config?.getMap("punctuator/symbols")
+    val alphabet: String
 
-    val alphabet get() = config?.getString("speller/alphabet")
+    init {
+        RimeConfig.openSchema(schemaId).use { c ->
+            switches =
+                c.getList("switches").mapNotNull decode@{ e ->
+                    try {
+                        Switch(
+                            name = e.getString("name"),
+                            options = e.getStringList("options"),
+                            reset = e.getInt("reset", -1),
+                            states = e.getStringList("states"),
+                        )
+                    } catch (e: Exception) {
+                        Timber.e(e, "Failed to decode switches of schema '$schemaId'")
+                        null
+                    }
+                }
+            symbols = c.getMap("punctuator/symbols")
+            alphabet = c.getString("speller/alphabet")
+        }
+    }
 
-    @Serializable
     data class Switch(
         val name: String = "",
         val options: List<String> = listOf(),
         val reset: Int = -1,
         val states: List<String> = listOf(),
-        @Transient var enabled: Int = 0,
+        var enabled: Int = 0,
     )
 }
diff --git a/app/src/main/java/com/osfans/trime/data/schema/SchemaManager.kt b/app/src/main/java/com/osfans/trime/data/schema/SchemaManager.kt
@@ -5,25 +5,22 @@
 package com.osfans.trime.data.schema
 
 import com.osfans.trime.core.Rime
-import kotlinx.serialization.builtins.ListSerializer
 
 object SchemaManager {
     private lateinit var currentSchema: Schema
     var visibleSwitches: List<Schema.Switch> = listOf()
 
-    private val defaultSchema = Schema()
-
     @JvmStatic
     fun init(schemaId: String) {
-        currentSchema = runCatching { Schema(schemaId) }.getOrDefault(defaultSchema)
-        visibleSwitches = currentSchema.switches
-            ?.decode(ListSerializer(Schema.Switch.serializer()))
-            ?.filter { it.states.isNotEmpty() } ?: listOf() // 剔除没有 states 条目项的值，它们不作为开关使用
+        currentSchema = Schema(schemaId)
+        visibleSwitches =
+            currentSchema.switches
+                .filter { it.states.isNotEmpty() } // 剔除没有 states 条目项的值，它们不作为开关使用
         updateSwitchOptions()
     }
 
     val activeSchema: Schema
-        get() = runCatching { currentSchema }.getOrDefault(defaultSchema)
+        get() = currentSchema
 
     @JvmStatic
     fun updateSwitchOptions() {
diff --git a/app/src/main/java/com/osfans/trime/data/theme/ThemeFilesManager.kt b/app/src/main/java/com/osfans/trime/data/theme/ThemeFilesManager.kt
@@ -8,8 +8,8 @@ package com.osfans.trime.data.theme
 import com.charleskorn.kaml.AnchorsAndAliases
 import com.charleskorn.kaml.Yaml
 import com.charleskorn.kaml.YamlConfiguration
-import com.charleskorn.kaml.YamlScalar
-import com.charleskorn.kaml.yamlMap
+import com.osfans.trime.core.RimeConfig
+import com.osfans.trime.data.base.DataManager
 import timber.log.Timber
 import java.io.File
 
@@ -25,17 +25,27 @@ object ThemeFilesManager {
 
     fun listThemes(dir: File): MutableList<ThemeItem> {
         val files = dir.listFiles { _, name -> name.endsWith("trime.yaml") } ?: return mutableListOf()
+        val deployedMap = hashMapOf<String, String>()
+        DataManager.stagingDir.list()?.forEach {
+            deployedMap[it] = it
+        }
+        DataManager.prebuiltDataDir.list()?.forEach {
+            deployedMap[it] = it
+        }
         return files
             .sortedByDescending { it.lastModified() }
             .mapNotNull decode@{
                 val item =
                     runCatching {
-                        val map =
-                            yaml
-                                .parseToYamlNode(it.bufferedReader().readText())
-                                .yamlMap
                         val configId = it.nameWithoutExtension
-                        val name = map.get<YamlScalar>("name")?.content ?: ""
+                        val name =
+                            if (deployedMap[it.name] != null) {
+                                RimeConfig.openConfig(configId).use {
+                                    it.getString("name")
+                                }
+                            } else {
+                                configId.removeSuffix(".trime")
+                            }
                         ThemeItem(configId, name)
                     }.getOrElse { e ->
                         Timber.w("Failed to decode theme file ${it.absolutePath}: ${e.message}")
diff --git a/app/src/main/java/com/osfans/trime/ime/symbol/TabManager.kt b/app/src/main/java/com/osfans/trime/ime/symbol/TabManager.kt
@@ -88,7 +88,7 @@ object TabManager {
 
             val symbolMaps = SchemaManager.activeSchema.symbols
             for ((key, value) in p) {
-                if (symbolMaps?.containsKey(value) == true) {
+                if (symbolMaps.containsKey(value)) {
                     keysList.add(SimpleKeyBean(value, key))
                 }
             }
diff --git a/app/src/main/jni/librime_jni/config.cc b/app/src/main/jni/librime_jni/config.cc
diff --git a/app/src/main/jni/librime_jni/jni-utils.h b/app/src/main/jni/librime_jni/jni-utils.h

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ object TabManager {`
`88`	`88`
`89`	`89`	`val symbolMaps = SchemaManager.activeSchema.symbols`
`90`	`90`	`for ((key, value) in p) {`
`91`		`- if (symbolMaps?.containsKey(value) == true) {`
	`91`	`+ if (symbolMaps.containsKey(value)) {`
`92`	`92`	`keysList.add(SimpleKeyBean(value, key))`
`93`	`93`	`}`
`94`	`94`	`}`