refactor: improve preferences serialization and security utility

This commit enhances the robustness of data persistence and optimizes the security infrastructure.

### Serialization & Data
- **UserPreferencesSerializer**: Now performs write operations on `Dispatchers.IO`.
- **UserPreferencesSerializer**: Replaced silent error recovery with `CorruptionException` when decoding fails.
- Cleaned up code by replacing fully qualified names with imports in `AIProviderConfigEntity`, `AppModule`, `HomeScreen`, and `SettingsScreen`.

### Security
- **SecurityUtil**: Implemented `SecretKey` caching to reduce Keystore access overhead.
- **SecurityUtil**: Introduced constants for `IV_SIZE` (12) and `TAG_SIZE` (128) to replace magic numbers.
- **SecurityUtil**: Improved error handling by using `Log.e` instead of `printStackTrace` and returning empty strings on failure to ensure consistent state.

Author: kid1412621

app/src/main/kotlin/me/nanova/summaryexpressive/UserPreferencesSerializer.kt

@@ -1,6 +1,10 @@
 package me.nanova.summaryexpressive
 
+import androidx.datastore.core.CorruptionException
 import androidx.datastore.core.Serializer
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.protobuf.ProtoBuf
 import java.io.InputStream
@@ -9,16 +13,19 @@ import java.io.OutputStream
 object UserPreferencesSerializer : Serializer<UserPreferences> {
     override val defaultValue: UserPreferences = UserPreferences()
 
+    @OptIn(ExperimentalSerializationApi::class)
     override suspend fun readFrom(input: InputStream): UserPreferences {
         return try {
             ProtoBuf.decodeFromByteArray(UserPreferences.serializer(), input.readBytes())
         } catch (exception: SerializationException) {
-            exception.printStackTrace()
-            defaultValue
+            throw CorruptionException("Cannot read ProtoBuf preferences", exception)
         }
     }
 
+    @OptIn(ExperimentalSerializationApi::class)
     override suspend fun writeTo(t: UserPreferences, output: OutputStream) {
-        output.write(ProtoBuf.encodeToByteArray(UserPreferences.serializer(), t))
+        withContext(Dispatchers.IO) {
+            output.write(ProtoBuf.encodeToByteArray(UserPreferences.serializer(), t))
+        }
     }
 }

app/src/main/kotlin/me/nanova/summaryexpressive/data/AIProviderConfigEntity.kt

@@ -2,6 +2,7 @@ package me.nanova.summaryexpressive.data
 
 import androidx.room.Entity
 import androidx.room.PrimaryKey
+import me.nanova.summaryexpressive.ProviderConfig
 import me.nanova.summaryexpressive.util.SecurityUtil
 
 @Entity(tableName = "ai_provider_config")
@@ -11,16 +12,16 @@ data class AIProviderConfigEntity(
     val baseUrl: String,
     val model: String
 ) {
-    fun toProviderConfig(): me.nanova.summaryexpressive.ProviderConfig {
-        return me.nanova.summaryexpressive.ProviderConfig(
+    fun toProviderConfig(): ProviderConfig {
+        return ProviderConfig(
             apiKey = SecurityUtil.decrypt(apiKey),
             baseUrl = baseUrl,
             model = model
         )
     }
 
     companion object {
-        fun fromProviderConfig(provider: String, config: me.nanova.summaryexpressive.ProviderConfig): AIProviderConfigEntity {
+        fun fromProviderConfig(provider: String, config: ProviderConfig): AIProviderConfigEntity {
             return AIProviderConfigEntity(
                 provider = provider,
                 apiKey = SecurityUtil.encrypt(config.apiKey),

app/src/main/kotlin/me/nanova/summaryexpressive/di/AppModule.kt

@@ -14,6 +14,7 @@ import io.ktor.client.plugins.cookies.AcceptAllCookiesStorage
 import io.ktor.client.plugins.cookies.HttpCookies
 import io.ktor.serialization.kotlinx.json.json
 import me.nanova.summaryexpressive.UserPreferencesRepository
+import me.nanova.summaryexpressive.data.AIProviderConfigDao
 import me.nanova.summaryexpressive.data.AppDatabase
 import me.nanova.summaryexpressive.data.HistoryDao
 import me.nanova.summaryexpressive.data.HistoryRepository
@@ -58,7 +59,7 @@ object AppModule {
 
     @Provides
     @Singleton
-    fun provideAIProviderConfigDao(appDatabase: AppDatabase): me.nanova.summaryexpressive.data.AIProviderConfigDao {
+    fun provideAIProviderConfigDao(appDatabase: AppDatabase): AIProviderConfigDao {
         return appDatabase.aiProviderConfigDao()
     }
 

app/src/main/kotlin/me/nanova/summaryexpressive/ui/page/HomeScreen.kt

@@ -5,6 +5,7 @@ import android.content.ContentValues
 import android.net.Uri
 import android.os.Environment
 import android.provider.MediaStore
+import android.widget.Toast
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
@@ -521,7 +522,11 @@ fun ProviderModelSheetContent(
                             modifier = Modifier
                                 .matchParentSize()
                                 .clickable {
-                                    android.widget.Toast.makeText(context, "Please go to settings page to configure before use", android.widget.Toast.LENGTH_SHORT).show()
+                                    Toast.makeText(
+                                        context,
+                                        "Please go to settings page to configure before use",
+                                        Toast.LENGTH_SHORT
+                                    ).show()
                                 }
                         )
                     }

app/src/main/kotlin/me/nanova/summaryexpressive/ui/page/SettingsScreen.kt

@@ -104,6 +104,7 @@ import androidx.compose.ui.unit.dp
 import androidx.core.net.toUri
 import kotlinx.coroutines.launch
 import me.nanova.summaryexpressive.BuildConfig
+import me.nanova.summaryexpressive.ProviderConfig
 import me.nanova.summaryexpressive.R
 import me.nanova.summaryexpressive.llm.AIProvider
 import me.nanova.summaryexpressive.ui.Nav
@@ -762,7 +763,7 @@ private fun ThemeSettingsDialog(
 private fun AIProviderSettingsDialog(
     onDismissRequest: () -> Unit,
     initialProvider: AIProvider,
-    providerConfigs: Map<String, me.nanova.summaryexpressive.ProviderConfig>,
+    providerConfigs: Map<String, ProviderConfig>,
     onConfirm: (provider: AIProvider, baseUrl: String, apiKey: String) -> Unit,
     onNext: (provider: AIProvider, baseUrl: String, apiKey: String) -> Unit,
 ) {

app/src/main/kotlin/me/nanova/summaryexpressive/util/SecurityUtil.kt

@@ -3,6 +3,7 @@ package me.nanova.summaryexpressive.util
 import android.security.keystore.KeyGenParameterSpec
 import android.security.keystore.KeyProperties
 import android.util.Base64
+import android.util.Log
 import java.security.KeyStore
 import javax.crypto.Cipher
 import javax.crypto.KeyGenerator
@@ -13,23 +14,30 @@ object SecurityUtil {
     private const val ANDROID_KEYSTORE = "AndroidKeyStore"
     private const val KEY_ALIAS = "summary_expressive_api_key_alias"
     private const val TRANSFORMATION = "AES/GCM/NoPadding"
+    private const val IV_SIZE = 12
+    private const val TAG_SIZE = 128
 
+    private var cachedKey: SecretKey? = null
+
+    @Synchronized
     private fun getSecretKey(): SecretKey {
-        val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE)
-        keyStore.load(null)
+        cachedKey?.let { return it }
+
+        val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE).apply { load(null) }
         if (!keyStore.containsAlias(KEY_ALIAS)) {
             val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE)
-            val keyGenParameterSpec = KeyGenParameterSpec.Builder(
+            val spec = KeyGenParameterSpec.Builder(
                 KEY_ALIAS,
                 KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
             )
                 .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
                 .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                 .build()
-            keyGenerator.init(keyGenParameterSpec)
+            keyGenerator.init(spec)
             keyGenerator.generateKey()
         }
-        return keyStore.getKey(KEY_ALIAS, null) as SecretKey
+
+        return (keyStore.getKey(KEY_ALIAS, null) as SecretKey).also { cachedKey = it }
     }
 
     fun encrypt(plainText: String): String {
@@ -44,26 +52,26 @@ object SecurityUtil {
             System.arraycopy(encryptedBytes, 0, combined, iv.size, encryptedBytes.size)
             Base64.encodeToString(combined, Base64.DEFAULT)
         } catch (e: Exception) {
-            e.printStackTrace()
-            plainText
+            Log.e("SecurityUtil", "Encryption failed", e)
+            ""
         }
     }
 
     fun decrypt(encryptedText: String): String {
         if (encryptedText.isEmpty()) return ""
         return try {
             val combined = Base64.decode(encryptedText, Base64.DEFAULT)
-            if (combined.size < 12) return encryptedText // Not encrypted or corrupted
+            if (combined.size < IV_SIZE) return encryptedText // Not encrypted or corrupted
             val cipher = Cipher.getInstance(TRANSFORMATION)
-            val iv = combined.copyOfRange(0, 12)
-            val encryptedBytes = combined.copyOfRange(12, combined.size)
-            val spec = GCMParameterSpec(128, iv)
+            val iv = combined.copyOfRange(0, IV_SIZE)
+            val encryptedBytes = combined.copyOfRange(IV_SIZE, combined.size)
+            val spec = GCMParameterSpec(TAG_SIZE, iv)
             cipher.init(Cipher.DECRYPT_MODE, getSecretKey(), spec)
             val decryptedBytes = cipher.doFinal(encryptedBytes)
             String(decryptedBytes, Charsets.UTF_8)
         } catch (e: Exception) {
-            e.printStackTrace()
-            encryptedText
+            Log.e("SecurityUtil", "Decryption failed", e)
+            ""
         }
     }
 }