Rename files and update package structure

Add tool classes related to displaying and refreshing data

manager/app/src/main/java/com/sukisu/ultra/flash/KernelFlash.kt

@@ -1,451 +0,0 @@
-package com.sukisu.ultra.flash
-
-import android.app.Activity
-import android.content.Context
-import android.net.Uri
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.CheckCircle
-import androidx.compose.material.icons.filled.Error
-import androidx.compose.material3.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
-import androidx.documentfile.provider.DocumentFile
-import com.sukisu.ultra.R
-import com.sukisu.ultra.utils.AssetsUtil
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
-import java.io.File
-import java.io.FileOutputStream
-import java.io.IOException
-
-
-/**
- * @author ShirkNeko
- * @date 2025/5/31.
- */
-data class FlashState(
-    val isFlashing: Boolean = false,
-    val isCompleted: Boolean = false,
-    val progress: Float = 0f,
-    val currentStep: String = "",
-    val logs: List<String> = emptyList(),
-    val error: String = ""
-)
-
-class HorizonKernelState {
-    private val _state = MutableStateFlow(FlashState())
-    val state: StateFlow<FlashState> = _state.asStateFlow()
-
-    fun updateProgress(progress: Float) {
-        _state.update { it.copy(progress = progress) }
-    }
-
-    fun updateStep(step: String) {
-        _state.update { it.copy(currentStep = step) }
-    }
-
-    fun addLog(log: String) {
-        _state.update {
-            it.copy(logs = it.logs + log)
-        }
-    }
-
-    fun setError(error: String) {
-        _state.update { it.copy(error = error) }
-    }
-
-    fun startFlashing() {
-        _state.update {
-            it.copy(
-                isFlashing = true,
-                isCompleted = false,
-                progress = 0f,
-                currentStep = "under preparation...",
-                logs = emptyList(),
-                error = ""
-            )
-        }
-    }
-
-    fun completeFlashing() {
-        _state.update { it.copy(isCompleted = true, progress = 1f) }
-    }
-
-    fun reset() {
-        _state.value = FlashState()
-    }
-}
-
-class HorizonKernelWorker(
-    private val context: Context,
-    private val state: HorizonKernelState,
-    private val slot: String? = null
-) : Thread() {
-    var uri: Uri? = null
-    private lateinit var filePath: String
-    private lateinit var binaryPath: String
-
-    private var onFlashComplete: (() -> Unit)? = null
-    private var originalSlot: String? = null
-
-    fun setOnFlashCompleteListener(listener: () -> Unit) {
-        onFlashComplete = listener
-    }
-
-    override fun run() {
-        state.startFlashing()
-        state.updateStep(context.getString(R.string.horizon_preparing))
-
-        filePath = "${context.filesDir.absolutePath}/${DocumentFile.fromSingleUri(context, uri!!)?.name}"
-        binaryPath = "${context.filesDir.absolutePath}/META-INF/com/google/android/update-binary"
-
-        try {
-            state.updateStep(context.getString(R.string.horizon_cleaning_files))
-            state.updateProgress(0.1f)
-            cleanup()
-
-            if (!rootAvailable()) {
-                state.setError(context.getString(R.string.root_required))
-                return
-            }
-
-            state.updateStep(context.getString(R.string.horizon_copying_files))
-            state.updateProgress(0.2f)
-            copy()
-
-            if (!File(filePath).exists()) {
-                state.setError(context.getString(R.string.horizon_copy_failed))
-                return
-            }
-
-            state.updateStep(context.getString(R.string.horizon_extracting_tool))
-            state.updateProgress(0.4f)
-            getBinary()
-
-            state.updateStep(context.getString(R.string.horizon_patching_script))
-            state.updateProgress(0.6f)
-            patch()
-
-            state.updateStep(context.getString(R.string.horizon_flashing))
-            state.updateProgress(0.7f)
-
-            val isAbDevice = isAbDevice()
-
-            if (isAbDevice && slot != null) {
-                state.updateStep(context.getString(R.string.horizon_getting_original_slot))
-                state.updateProgress(0.72f)
-                originalSlot = runCommandGetOutput(true, "getprop ro.boot.slot_suffix")
-
-                state.updateStep(context.getString(R.string.horizon_setting_target_slot))
-                state.updateProgress(0.74f)
-                runCommand(true, "resetprop -n ro.boot.slot_suffix _$slot")
-            }
-
-            flash()
-
-            if (isAbDevice && !originalSlot.isNullOrEmpty()) {
-                state.updateStep(context.getString(R.string.horizon_restoring_original_slot))
-                state.updateProgress(0.8f)
-                runCommand(true, "resetprop ro.boot.slot_suffix $originalSlot")
-            }
-
-            state.updateStep(context.getString(R.string.horizon_flash_complete_status))
-            state.completeFlashing()
-
-            (context as? Activity)?.runOnUiThread {
-                onFlashComplete?.invoke()
-            }
-        } catch (e: Exception) {
-            state.setError(e.message ?: context.getString(R.string.horizon_unknown_error))
-
-            if (isAbDevice() && !originalSlot.isNullOrEmpty()) {
-                state.updateStep(context.getString(R.string.horizon_restoring_original_slot))
-                state.updateProgress(0.8f)
-                runCommand(true, "resetprop ro.boot.slot_suffix $originalSlot")
-            }
-        }
-    }
-
-    // 检查设备是否为AB分区设备
-    private fun isAbDevice(): Boolean {
-        val abUpdate = runCommandGetOutput(true, "getprop ro.build.ab_update")?.trim() ?: ""
-        if (abUpdate.equals("false", ignoreCase = true) || abUpdate.isEmpty()) {
-            return false
-        }
-
-        val slotSuffix = runCommandGetOutput(true, "getprop ro.boot.slot_suffix")
-        return !slotSuffix.isNullOrEmpty()
-    }
-
-    private fun cleanup() {
-        runCommand(false, "find ${context.filesDir.absolutePath} -type f ! -name '*.jpg' ! -name '*.png' -delete")
-    }
-
-    private fun copy() {
-        uri?.let { safeUri ->
-            context.contentResolver.openInputStream(safeUri)?.use { input ->
-                FileOutputStream(File(filePath)).use { output ->
-                    input.copyTo(output)
-                }
-            }
-        }
-    }
-
-    private fun getBinary() {
-        runCommand(false, "unzip \"$filePath\" \"*/update-binary\" -d ${context.filesDir.absolutePath}")
-        if (!File(binaryPath).exists()) {
-            throw IOException("Failed to extract update-binary")
-        }
-    }
-
-    private fun patch() {
-        val kernelVersion = runCommandGetOutput(true, "cat /proc/version")
-        val versionRegex = """\d+\.\d+\.\d+""".toRegex()
-        val version = kernelVersion?.let { versionRegex.find(it) }?.value ?: ""
-        val toolName = if (version.isNotEmpty()) {
-            val parts = version.split('.')
-            if (parts.size >= 2) {
-                val major = parts[0].toIntOrNull() ?: 0
-                val minor = parts[1].toIntOrNull() ?: 0
-                if (major < 5 || (major == 5 && minor <= 10)) "5_10" else "5_15+"
-            } else {
-                "5_15+"
-            }
-        } else {
-            "5_15+"
-        }
-        val toolPath = "${context.filesDir.absolutePath}/mkbootfs"
-        AssetsUtil.exportFiles(context, "$toolName-mkbootfs", toolPath)
-        state.addLog("${context.getString(R.string.kernel_version_log, version)} ${context.getString(R.string.tool_version_log, toolName)}")
-        runCommand(false, "sed -i '/chmod -R 755 tools bin;/i cp -f $toolPath \$AKHOME/tools;' $binaryPath")
-    }
-
-    private fun flash() {
-        val process = ProcessBuilder("su")
-            .redirectErrorStream(true)
-            .start()
-
-        try {
-            process.outputStream.bufferedWriter().use { writer ->
-                writer.write("export POSTINSTALL=${context.filesDir.absolutePath}\n")
-
-                // 写入槽位信息到临时文件
-                slot?.let { selectedSlot ->
-                    writer.write("echo \"$selectedSlot\" > ${context.filesDir.absolutePath}/bootslot\n")
-                }
-
-                // 构建刷写命令
-                val flashCommand = buildString {
-                    append("sh $binaryPath 3 1 \"$filePath\"")
-                    if (slot != null) {
-                        append(" \"$(cat ${context.filesDir.absolutePath}/bootslot)\"")
-                    }
-                    append(" && touch ${context.filesDir.absolutePath}/done\n")
-                }
-
-                writer.write(flashCommand)
-                writer.write("exit\n")
-                writer.flush()
-            }
-
-            process.inputStream.bufferedReader().use { reader ->
-                reader.lineSequence().forEach { line ->
-                    if (line.startsWith("ui_print")) {
-                        val logMessage = line.removePrefix("ui_print").trim()
-                        state.addLog(logMessage)
-
-                        when {
-                            logMessage.contains("extracting", ignoreCase = true) -> {
-                                state.updateProgress(0.75f)
-                            }
-                            logMessage.contains("installing", ignoreCase = true) -> {
-                                state.updateProgress(0.85f)
-                            }
-                            logMessage.contains("complete", ignoreCase = true) -> {
-                                state.updateProgress(0.95f)
-                            }
-                        }
-                    }
-                }
-            }
-        } finally {
-            process.destroy()
-        }
-
-        if (!File("${context.filesDir.absolutePath}/done").exists()) {
-            throw IOException(context.getString(R.string.flash_failed_message))
-        }
-    }
-
-    private fun runCommand(su: Boolean, cmd: String): Int {
-        val process = ProcessBuilder(if (su) "su" else "sh")
-            .redirectErrorStream(true)
-            .start()
-
-        return try {
-            process.outputStream.bufferedWriter().use { writer ->
-                writer.write("$cmd\n")
-                writer.write("exit\n")
-                writer.flush()
-            }
-            process.waitFor()
-        } finally {
-            process.destroy()
-        }
-    }
-
-    private fun runCommandGetOutput(su: Boolean, cmd: String): String? {
-        val process = ProcessBuilder(if (su) "su" else "sh")
-            .redirectErrorStream(true)
-            .start()
-
-        return try {
-            process.outputStream.bufferedWriter().use { writer ->
-                writer.write("$cmd\n")
-                writer.write("exit\n")
-                writer.flush()
-            }
-            process.inputStream.bufferedReader().use { reader ->
-                reader.readText().trim()
-            }
-        } catch (_: Exception) {
-            ""
-        } finally {
-            process.destroy()
-        }
-    }
-
-    private fun rootAvailable(): Boolean {
-        return try {
-            val process = Runtime.getRuntime().exec("su -c id")
-            val exitValue = process.waitFor()
-            exitValue == 0
-        } catch (_: Exception) {
-            false
-        }
-    }
-}
-
-@Composable
-fun HorizonKernelFlashProgress(state: FlashState) {
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(16.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.surfaceVariant
-        )
-    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalAlignment = Alignment.CenterHorizontally
-        ) {
-            Text(
-                text = stringResource(id = R.string.horizon_flash_title),
-                style = MaterialTheme.typography.titleMedium,
-                modifier = Modifier.padding(bottom = 8.dp)
-            )
-
-            LinearProgressIndicator(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(vertical = 8.dp),
-                progress = { state.progress },
-            )
-
-            Text(
-                text = state.currentStep,
-                style = MaterialTheme.typography.bodyMedium,
-                modifier = Modifier.padding(vertical = 4.dp)
-            )
-
-            if (state.logs.isNotEmpty()) {
-                Text(
-                    text = stringResource(id = R.string.horizon_logs_label),
-                    style = MaterialTheme.typography.labelMedium,
-                    modifier = Modifier
-                        .align(Alignment.Start)
-                        .padding(top = 8.dp, bottom = 4.dp)
-                )
-
-                Surface(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .heightIn(max = 230.dp)
-                        .padding(vertical = 4.dp),
-                    color = MaterialTheme.colorScheme.surface,
-                    tonalElevation = 1.dp,
-                    shape = MaterialTheme.shapes.small
-                ) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(8.dp)
-                            .verticalScroll(rememberScrollState())
-                    ) {
-                        state.logs.forEach { log ->
-                            Text(
-                                text = log,
-                                style = MaterialTheme.typography.bodySmall,
-                                modifier = Modifier.padding(vertical = 2.dp),
-                                overflow = TextOverflow.Ellipsis,
-                                maxLines = 1
-                            )
-                        }
-                    }
-                }
-            }
-
-            if (state.error.isNotEmpty()) {
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(top = 8.dp)
-                ) {
-                    Icon(
-                        imageVector = Icons.Default.Error,
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.error,
-                        modifier = Modifier.padding(end = 8.dp)
-                    )
-                    Text(
-                        text = state.error,
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.error
-                    )
-                }
-            } else if (state.isCompleted) {
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(top = 8.dp)
-                ) {
-                    Icon(
-                        imageVector = Icons.Default.CheckCircle,
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.primary,
-                        modifier = Modifier.padding(end = 8.dp)
-                    )
-                    Text(
-                        text = stringResource(id = R.string.horizon_flash_complete),
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.primary
-                    )
-                }
-            }
-        }
-    }
-}

manager/app/src/main/java/com/sukisu/ultra/ui/MainActivity.kt

@@ -1,60 +1,36 @@
 package com.sukisu.ultra.ui
 
-import android.annotation.SuppressLint
 import android.content.Context
 import android.content.res.Configuration
-import android.database.ContentObserver
 import android.os.Build
 import android.os.Bundle
-import android.os.Handler
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
-import androidx.compose.animation.*
-import androidx.compose.animation.core.tween
 import androidx.compose.foundation.layout.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.navigation.NavBackStackEntry
-import androidx.navigation.NavHostController
+import androidx.lifecycle.lifecycleScope
+import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import com.ramcosta.composedestinations.DestinationsNavHost
-import com.ramcosta.composedestinations.animations.NavHostAnimatedDestinationStyle
 import com.ramcosta.composedestinations.generated.NavGraphs
 import com.ramcosta.composedestinations.generated.destinations.ExecuteModuleActionScreenDestination
 import com.ramcosta.composedestinations.spec.NavHostGraphSpec
-import com.ramcosta.composedestinations.spec.RouteOrDirection
-import com.ramcosta.composedestinations.utils.isRouteOnBackStackAsState
-import com.ramcosta.composedestinations.utils.rememberDestinationsNavigator
 import io.sukisu.ultra.UltraToolInstall
-import com.sukisu.ultra.Natives
 import com.sukisu.ultra.ksuApp
-import com.sukisu.ultra.ui.data.AppData
-import com.sukisu.ultra.ui.screen.BottomBarDestination
+import zako.zako.zako.zakoui.activity.util.AppData
 import com.sukisu.ultra.ui.theme.*
-import com.sukisu.ultra.ui.theme.CardConfig.cardAlpha
-import com.sukisu.ultra.ui.util.*
-import androidx.core.content.edit
-import com.sukisu.ultra.ui.data.AppData.DataRefreshManager
-import com.sukisu.ultra.ui.theme.CardConfig.cardElevation
-import com.sukisu.ultra.ui.webui.initPlatform
-import java.util.Locale
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
-import androidx.navigation.compose.currentBackStackEntryAsState
-import androidx.lifecycle.lifecycleScope
-import com.sukisu.ultra.ui.data.AppData.getKpmVersionUse
+import zako.zako.zako.zakoui.activity.util.*
+import zako.zako.zako.zakoui.activity.component.BottomBar
+import com.sukisu.ultra.ui.util.LocalSnackbarHost
+import com.sukisu.ultra.ui.util.install
 import com.sukisu.ultra.ui.viewmodel.HomeViewModel
 import com.sukisu.ultra.ui.viewmodel.SuperUserViewModel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.Dispatchers
+import com.sukisu.ultra.ui.webui.initPlatform
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
 
 class MainActivity : ComponentActivity() {
     private lateinit var superUserViewModel: SuperUserViewModel
@@ -66,62 +42,19 @@ class MainActivity : ComponentActivity() {
         val showKpmInfo: Boolean = true
     )
 
-    private inner class ThemeChangeContentObserver(
-        handler: Handler,
-        private val onThemeChanged: () -> Unit
-    ) : ContentObserver(handler) {
-        override fun onChange(selfChange: Boolean) {
-            super.onChange(selfChange)
-            onThemeChanged()
-        }
-    }
-
-    // 应用保存的语言设置
-    @SuppressLint("ObsoleteSdkInt")
-    private fun applyLanguageSetting() {
-        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
-        val languageCode = prefs.getString("app_language", "") ?: ""
-
-        if (languageCode.isNotEmpty()) {
-            val locale = Locale.forLanguageTag(languageCode)
-            Locale.setDefault(locale)
-
-            val resources = resources
-            val config = Configuration(resources.configuration)
-            config.setLocale(locale)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                createConfigurationContext(config)
-            } else {
-                @Suppress("DEPRECATION")
-                resources.updateConfiguration(config, resources.displayMetrics)
-            }
-        }
-    }
+    private lateinit var themeChangeObserver: ThemeChangeContentObserver
 
     override fun attachBaseContext(newBase: Context) {
-        val prefs = newBase.getSharedPreferences("settings", MODE_PRIVATE)
-        val languageCode = prefs.getString("app_language", "") ?: ""
-
-        var context = newBase
-        if (languageCode.isNotEmpty()) {
-            val locale = Locale.forLanguageTag(languageCode)
-            Locale.setDefault(locale)
-
-            val config = Configuration(newBase.resources.configuration)
-            config.setLocale(locale)
-            context = newBase.createConfigurationContext(config)
-        }
-
+        val context = LocaleUtils.applyLocale(newBase)
         super.attachBaseContext(context)
     }
 
-    @SuppressLint("RestrictedApi")
     override fun onCreate(savedInstanceState: Bundle?) {
         // 确保应用正确的语言设置
-        applyLanguageSetting()
+        LocaleUtils.applyLanguageSetting(this)
 
         // 应用自定义 DPI
-        applyCustomDpi()
+        DisplayUtils.applyCustomDpi(this)
 
         // Enable edge to edge
         enableEdgeToEdge()
@@ -148,51 +81,15 @@ class MainActivity : ComponentActivity() {
         }
 
         // 数据刷新协程
-        startDataRefreshCoroutine()
+        DataRefreshUtils.startDataRefreshCoroutine(lifecycleScope)
 
-        startSettingsMonitorCoroutine()
+        DataRefreshUtils.startSettingsMonitorCoroutine(lifecycleScope, this, settingsStateFlow)
 
-        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
-        val isFirstRun = prefs.getBoolean("is_first_run", true)
+        // 初始化主题相关设置
+        ThemeUtils.initializeThemeSettings(this, settingsStateFlow)
 
-        settingsStateFlow.value = SettingsState(
-            isHideOtherInfo = prefs.getBoolean("is_hide_other_info", false),
-            showKpmInfo = prefs.getBoolean("show_kpm_info", true)
-        )
-
-        if (isFirstRun) {
-            ThemeConfig.preventBackgroundRefresh = false
-            getSharedPreferences("theme_prefs", MODE_PRIVATE).edit {
-                putBoolean("prevent_background_refresh", false)
-            }
-            prefs.edit { putBoolean("is_first_run", false) }
-        }
-
-        // 加载保存的背景设置
-        loadThemeMode()
-        loadThemeColors()
-        loadDynamicColorState()
-        CardConfig.load(applicationContext)
-
-        val contentObserver = ThemeChangeContentObserver(Handler(mainLooper)) {
-            runOnUiThread {
-                if (!ThemeConfig.preventBackgroundRefresh) {
-                    ThemeConfig.backgroundImageLoaded = false
-                    loadCustomBackground()
-                }
-            }
-        }
-
-        contentResolver.registerContentObserver(
-            android.provider.Settings.System.getUriFor("ui_night_mode"),
-            false,
-            contentObserver
-        )
-
-        val destroyListeners = mutableListOf<() -> Unit>()
-        destroyListeners.add {
-            contentResolver.unregisterContentObserver(contentObserver)
-        }
+        // 设置主题变化监听器
+        themeChangeObserver = ThemeUtils.registerThemeChangeObserver(this)
 
         val isManager = AppData.isManager(ksuApp.packageName)
         if (isManager) {
@@ -221,13 +118,10 @@ class MainActivity : ComponentActivity() {
                 ) {
                     Scaffold(
                         bottomBar = {
-                            AnimatedVisibility(
-                                visible = showBottomBar,
-                                enter = slideInVertically(initialOffsetY = { it }) + fadeIn(),
-                                exit = slideOutVertically(targetOffsetY = { it }) + fadeOut()
-                            ) {
-                                BottomBar(navController)
-                            }
+                            AnimatedBottomBar.AnimatedBottomBarWrapper(
+                                showBottomBar = showBottomBar,
+                                content = { BottomBar(navController) }
+                            )
                         },
                         contentWindowInsets = WindowInsets(0, 0, 0, 0)
                     ) { innerPadding ->
@@ -235,12 +129,7 @@ class MainActivity : ComponentActivity() {
                             modifier = Modifier.padding(innerPadding),
                             navGraph = NavGraphs.root as NavHostGraphSpec,
                             navController = navController,
-                            defaultTransitions = object : NavHostAnimatedDestinationStyle() {
-                                override val enterTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> EnterTransition
-                                    get() = { fadeIn(animationSpec = tween(340)) }
-                                override val exitTransition: AnimatedContentTransitionScope<NavBackStackEntry>.() -> ExitTransition
-                                    get() = { fadeOut(animationSpec = tween(340)) }
-                            }
+                            defaultTransitions = NavigationUtils.defaultTransitions()
                         )
                     }
                 }
@@ -248,64 +137,15 @@ class MainActivity : ComponentActivity() {
         }
     }
 
-    // 数据刷新协程
-    private fun startDataRefreshCoroutine() {
-        lifecycleScope.launch(Dispatchers.IO) {
-            while (isActive) {
-                DataRefreshManager.refreshData()
-                delay(5000)
-            }
-        }
-    }
-
-    private fun startSettingsMonitorCoroutine() {
-        lifecycleScope.launch(Dispatchers.IO) {
-            while (isActive) {
-                val prefs = getSharedPreferences("settings", MODE_PRIVATE)
-                settingsStateFlow.value = SettingsState(
-                    isHideOtherInfo = prefs.getBoolean("is_hide_other_info", false),
-                    showKpmInfo = prefs.getBoolean("show_kpm_info", true)
-                )
-                delay(1000)
-            }
-        }
-    }
-
-    // 应用自定义DPI设置
-    private fun applyCustomDpi() {
-        val prefs = getSharedPreferences("settings", MODE_PRIVATE)
-        val customDpi = prefs.getInt("app_dpi", 0)
-
-        if (customDpi > 0) {
-            try {
-                val resources = resources
-                val metrics = resources.displayMetrics
-                metrics.density = customDpi / 160f
-                @Suppress("DEPRECATION")
-                metrics.scaledDensity = customDpi / 160f
-                metrics.densityDpi = customDpi
-            } catch (e: Exception) {
-                e.printStackTrace()
-            }
-        }
-    }
-
     override fun onPause() {
         super.onPause()
-        CardConfig.save(applicationContext)
-        getSharedPreferences("theme_prefs", MODE_PRIVATE).edit {
-            putBoolean("prevent_background_refresh", true)
-        }
-        ThemeConfig.preventBackgroundRefresh = true
+        ThemeUtils.onActivityPause(this)
     }
 
     override fun onResume() {
         super.onResume()
-        applyLanguageSetting()
-
-        if (!ThemeConfig.backgroundImageLoaded && !ThemeConfig.preventBackgroundRefresh) {
-            loadCustomBackground()
-        }
+        LocaleUtils.applyLanguageSetting(this)
+        ThemeUtils.onActivityResume()
 
         lifecycleScope.launch {
             superUserViewModel.fetchAppList()
@@ -315,213 +155,16 @@ class MainActivity : ComponentActivity() {
             homeViewModel.initializeData()
         }
 
-        lifecycleScope.launch {
-            DataRefreshManager.refreshData()
-        }
+        DataRefreshUtils.refreshData(lifecycleScope)
     }
 
-    private val destroyListeners = mutableListOf<() -> Unit>()
-
     override fun onDestroy() {
-        destroyListeners.forEach { it() }
+        ThemeUtils.unregisterThemeChangeObserver(this, themeChangeObserver)
         super.onDestroy()
     }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
-        applyLanguageSetting()
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun BottomBar(navController: NavHostController) {
-    val navigator = navController.rememberDestinationsNavigator()
-    val isFullFeatured = AppData.isFullFeatured(ksuApp.packageName)
-    val kpmVersion = getKpmVersionUse()
-    val cardColor = MaterialTheme.colorScheme.surfaceContainer
-    val activity = LocalContext.current as MainActivity
-    val settings by activity.settingsStateFlow.collectAsState()
-
-    // 检查是否隐藏红点
-    val isHideOtherInfo = settings.isHideOtherInfo
-    val showKpmInfo = settings.showKpmInfo
-
-    // 收集计数数据
-    val superuserCount by DataRefreshManager.superuserCount.collectAsState()
-    val moduleCount by DataRefreshManager.moduleCount.collectAsState()
-    val kpmModuleCount by DataRefreshManager.kpmModuleCount.collectAsState()
-
-
-    NavigationBar(
-        modifier = Modifier.windowInsetsPadding(
-            WindowInsets.navigationBars.only(WindowInsetsSides.Horizontal)
-        ),
-        containerColor = TopAppBarDefaults.topAppBarColors(
-            containerColor = cardColor.copy(alpha = cardAlpha),
-            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
-        ).containerColor,
-        tonalElevation = cardElevation
-    ) {
-        BottomBarDestination.entries.forEach { destination ->
-            if (destination == BottomBarDestination.Kpm) {
-                if (kpmVersion.isNotEmpty() && !kpmVersion.startsWith("Error") && showKpmInfo && Natives.version >= Natives.MINIMAL_SUPPORTED_KPM) {
-                    if (!isFullFeatured && destination.rootRequired) return@forEach
-                    val isCurrentDestOnBackStack by navController.isRouteOnBackStackAsState(destination.direction)
-                    NavigationBarItem(
-                        selected = isCurrentDestOnBackStack,
-                        onClick = {
-                            if (!isCurrentDestOnBackStack) {
-                                navigator.popBackStack(destination.direction, false)
-                            }
-                            navigator.navigate(destination.direction) {
-                                popUpTo(NavGraphs.root as RouteOrDirection) {
-                                    saveState = true
-                                }
-                                launchSingleTop = true
-                                restoreState = true
-                            }
-                        },
-                        icon = {
-                            BadgedBox(
-                                badge = {
-                                    if (kpmModuleCount > 0 && !isHideOtherInfo) {
-                                        Badge(
-                                            containerColor = MaterialTheme.colorScheme.secondary
-                                        ) {
-                                            Text(
-                                                text = kpmModuleCount.toString(),
-                                                style = MaterialTheme.typography.labelSmall
-                                            )
-                                        }
-                                    }
-                                }
-                            ) {
-                                if (isCurrentDestOnBackStack) {
-                                    Icon(destination.iconSelected, stringResource(destination.label))
-                                } else {
-                                    Icon(destination.iconNotSelected, stringResource(destination.label))
-                                }
-                            }
-                        },
-                        label = { Text(stringResource(destination.label),style = MaterialTheme.typography.labelMedium) },
-                        alwaysShowLabel = false
-                    )
-                }
-            } else if (destination == BottomBarDestination.SuperUser) {
-                if (!isFullFeatured && destination.rootRequired) return@forEach
-                val isCurrentDestOnBackStack by navController.isRouteOnBackStackAsState(destination.direction)
-
-                NavigationBarItem(
-                    selected = isCurrentDestOnBackStack,
-                    onClick = {
-                        if (isCurrentDestOnBackStack) {
-                            navigator.popBackStack(destination.direction, false)
-                        }
-                        navigator.navigate(destination.direction) {
-                            popUpTo(NavGraphs.root) {
-                                saveState = true
-                            }
-                            launchSingleTop = true
-                            restoreState = true
-                        }
-                    },
-                    icon = {
-                        BadgedBox(
-                            badge = {
-                                if (superuserCount > 0 && !isHideOtherInfo) {
-                                    Badge(
-                                        containerColor = MaterialTheme.colorScheme.secondary
-                                    ) {
-                                        Text(
-                                            text = superuserCount.toString(),
-                                            style = MaterialTheme.typography.labelSmall
-                                        )
-                                    }
-                                }
-                            }
-                        ) {
-                            if (isCurrentDestOnBackStack) {
-                                Icon(destination.iconSelected, stringResource(destination.label))
-                            } else {
-                                Icon(destination.iconNotSelected, stringResource(destination.label))
-                            }
-                        }
-                    },
-                    label = { Text(stringResource(destination.label),style = MaterialTheme.typography.labelMedium) },
-                    alwaysShowLabel = false
-                )
-            } else if (destination == BottomBarDestination.Module) {
-                if (!isFullFeatured && destination.rootRequired) return@forEach
-                val isCurrentDestOnBackStack by navController.isRouteOnBackStackAsState(destination.direction)
-
-                NavigationBarItem(
-                    selected = isCurrentDestOnBackStack,
-                    onClick = {
-                        if (isCurrentDestOnBackStack) {
-                            navigator.popBackStack(destination.direction, false)
-                        }
-                        navigator.navigate(destination.direction) {
-                            popUpTo(NavGraphs.root) {
-                                saveState = true
-                            }
-                            launchSingleTop = true
-                            restoreState = true
-                        }
-                    },
-                    icon = {
-                        BadgedBox(
-                            badge = {
-                                if (moduleCount > 0 && !isHideOtherInfo) {
-                                    Badge(
-                                        containerColor = MaterialTheme.colorScheme.secondary                              ) {
-                                        Text(
-                                            text = moduleCount.toString(),
-                                            style = MaterialTheme.typography.labelSmall
-                                        )
-                                    }
-                                }
-                            }
-                        ) {
-                            if (isCurrentDestOnBackStack) {
-                                Icon(destination.iconSelected, stringResource(destination.label))
-                            } else {
-                                Icon(destination.iconNotSelected, stringResource(destination.label))
-                            }
-                        }
-                    },
-                    label = { Text(stringResource(destination.label),style = MaterialTheme.typography.labelMedium) },
-                    alwaysShowLabel = false
-                )
-            } else {
-                if (!isFullFeatured && destination.rootRequired) return@forEach
-                val isCurrentDestOnBackStack by navController.isRouteOnBackStackAsState(destination.direction)
-
-                NavigationBarItem(
-                    selected = isCurrentDestOnBackStack,
-                    onClick = {
-                        if (isCurrentDestOnBackStack) {
-                            navigator.popBackStack(destination.direction, false)
-                        }
-                        navigator.navigate(destination.direction) {
-                            popUpTo(NavGraphs.root) {
-                                saveState = true
-                            }
-                            launchSingleTop = true
-                            restoreState = true
-                        }
-                    },
-                    icon = {
-                        if (isCurrentDestOnBackStack) {
-                            Icon(destination.iconSelected, stringResource(destination.label))
-                        } else {
-                            Icon(destination.iconNotSelected, stringResource(destination.label))
-                        }
-                    },
-                    label = { Text(stringResource(destination.label),style = MaterialTheme.typography.labelMedium) },
-                    alwaysShowLabel = false
-                )
-            }
-        }
+        LocaleUtils.applyLanguageSetting(this)
     }
 }

manager/app/src/main/java/com/sukisu/ultra/ui/data/AppData.kt

@@ -1,109 +0,0 @@
-package com.sukisu.ultra.ui.data
-
-import com.sukisu.ultra.Natives
-import com.sukisu.ultra.ui.util.getKpmModuleCount
-import com.sukisu.ultra.ui.util.getKpmVersion
-import com.sukisu.ultra.ui.util.rootAvailable
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.withContext
-import com.sukisu.ultra.ui.util.getModuleCount
-import com.sukisu.ultra.ui.util.getSuperuserCount
-
-object AppData {
-    object DataRefreshManager {
-        // 私有状态流
-        private val _superuserCount = MutableStateFlow(0)
-        private val _moduleCount = MutableStateFlow(0)
-        private val _kpmModuleCount = MutableStateFlow(0)
-
-        // 公开的只读状态流
-        val superuserCount: StateFlow<Int> = _superuserCount.asStateFlow()
-        val moduleCount: StateFlow<Int> = _moduleCount.asStateFlow()
-        val kpmModuleCount: StateFlow<Int> = _kpmModuleCount.asStateFlow()
-
-        /**
-         * 刷新所有数据计数
-         */
-        fun refreshData() {
-            _superuserCount.value = getSuperuserCountUse()
-            _moduleCount.value = getModuleCountUse()
-            _kpmModuleCount.value = getKpmModuleCountUse()
-        }
-
-        /**
-         * 异步刷新所有数据
-         */
-        suspend fun refreshDataAsync() = withContext(Dispatchers.IO) {
-            refreshData()
-        }
-    }
-
-    /**
-     * 获取超级用户应用计数
-     */
-    fun getSuperuserCountUse(): Int {
-        return try {
-            if (!rootAvailable()) return 0
-            getSuperuserCount()
-        } catch (_: Exception) {
-            0
-        }
-    }
-
-    /**
-     * 获取模块计数
-     */
-    fun getModuleCountUse(): Int {
-        return try {
-            if (!rootAvailable()) return 0
-            getModuleCount()
-        } catch (_: Exception) {
-            0
-        }
-    }
-
-    /**
-     * 获取KPM模块计数
-     */
-    fun getKpmModuleCountUse(): Int {
-        return try {
-            if (!rootAvailable()) return 0
-            val kpmVersion = getKpmVersionUse()
-            if (kpmVersion.isEmpty() || kpmVersion.startsWith("Error")) return 0
-            getKpmModuleCount()
-        } catch (_: Exception) {
-            0
-        }
-    }
-
-    /**
-     * 获取KPM版本
-     */
-    fun getKpmVersionUse(): String {
-        return try {
-            if (!rootAvailable()) return ""
-            val version = getKpmVersion()
-            if (version.isEmpty()) "" else version
-        } catch (e: Exception) {
-            "Error: ${e.message}"
-        }
-    }
-
-    /**
-     * 检查是否具有管理员权限
-     */
-    fun isManager(packageName: String): Boolean {
-        return Natives.becomeManager(packageName)
-    }
-
-    /**
-     * 检查是否是完整功能模式
-     */
-    fun isFullFeatured(packageName: String): Boolean {
-        val isManager = Natives.becomeManager(packageName)
-        return isManager && !Natives.requireNewKernel() && rootAvailable()
-    }
-}

manager/app/src/main/java/com/sukisu/ultra/ui/screen/KernelFlash.kt

@@ -1,416 +0,0 @@
-package com.sukisu.ultra.ui.screen
-
-import android.net.Uri
-import android.os.Environment
-import androidx.activity.compose.BackHandler
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.material.icons.filled.CheckCircle
-import androidx.compose.material.icons.filled.Error
-import androidx.compose.material.icons.filled.Refresh
-import androidx.compose.material.icons.filled.Save
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import com.ramcosta.composedestinations.annotation.Destination
-import com.ramcosta.composedestinations.annotation.RootGraph
-import com.ramcosta.composedestinations.navigation.DestinationsNavigator
-import com.sukisu.ultra.R
-import com.sukisu.ultra.flash.HorizonKernelState
-import com.sukisu.ultra.flash.HorizonKernelWorker
-import com.sukisu.ultra.ui.component.KeyEventBlocker
-import com.sukisu.ultra.ui.util.*
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import java.io.File
-import java.text.SimpleDateFormat
-import java.util.*
-import androidx.compose.ui.input.key.Key
-import androidx.compose.ui.input.key.key
-import com.sukisu.ultra.ui.theme.CardConfig
-
-/**
- * @author ShirkNeko
- * @date 2025/5/31.
- */
-private object KernelFlashStateHolder {
-    var currentState: HorizonKernelState? = null
-    var currentUri: Uri? = null
-    var currentSlot: String? = null
-    var isFlashing = false
-}
-
-/**
- * Kernel刷写界面
- */
-@OptIn(ExperimentalMaterial3Api::class)
-@Destination<RootGraph>
-@Composable
-fun KernelFlashScreen(
-    navigator: DestinationsNavigator,
-    kernelUri: Uri,
-    selectedSlot: String? = null
-) {
-    val context = LocalContext.current
-    val scrollState = rememberScrollState()
-    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
-    val snackBarHost = LocalSnackbarHost.current
-    val scope = rememberCoroutineScope()
-    var logText by rememberSaveable { mutableStateOf("") }
-    var showFloatAction by rememberSaveable { mutableStateOf(false) }
-    val logContent = rememberSaveable { StringBuilder() }
-    val horizonKernelState = remember {
-        if (KernelFlashStateHolder.currentState != null &&
-            KernelFlashStateHolder.currentUri == kernelUri &&
-            KernelFlashStateHolder.currentSlot == selectedSlot) {
-            KernelFlashStateHolder.currentState!!
-        } else {
-            HorizonKernelState().also {
-                KernelFlashStateHolder.currentState = it
-                KernelFlashStateHolder.currentUri = kernelUri
-                KernelFlashStateHolder.currentSlot = selectedSlot
-                KernelFlashStateHolder.isFlashing = false
-            }
-        }
-    }
-
-    val flashState by horizonKernelState.state.collectAsState()
-    val logSavedString = stringResource(R.string.log_saved)
-
-    val onFlashComplete = {
-        showFloatAction = true
-        KernelFlashStateHolder.isFlashing = false
-    }
-
-    // 开始刷写
-    LaunchedEffect(Unit) {
-        if (!KernelFlashStateHolder.isFlashing && !flashState.isCompleted && flashState.error.isEmpty()) {
-            withContext(Dispatchers.IO) {
-                KernelFlashStateHolder.isFlashing = true
-                val worker = HorizonKernelWorker(
-                    context = context,
-                    state = horizonKernelState,
-                    slot = selectedSlot
-                )
-                worker.uri = kernelUri
-                worker.setOnFlashCompleteListener(onFlashComplete)
-                worker.start()
-
-                // 监听日志更新
-                while (!flashState.isCompleted && flashState.error.isEmpty()) {
-                    if (flashState.logs.isNotEmpty()) {
-                        logText = flashState.logs.joinToString("\n")
-                        logContent.clear()
-                        logContent.append(logText)
-                    }
-                    kotlinx.coroutines.delay(100)
-                }
-
-                if (flashState.error.isNotEmpty()) {
-                    logText += "\n${flashState.error}\n"
-                    logContent.append("\n${flashState.error}\n")
-                    KernelFlashStateHolder.isFlashing = false
-                } else if (flashState.isCompleted) {
-                    logText += "\n${context.getString(R.string.horizon_flash_complete)}\n\n\n"
-                    logContent.append("\n${context.getString(R.string.horizon_flash_complete)}\n\n\n")
-                }
-            }
-        } else {
-            logText = flashState.logs.joinToString("\n")
-            if (flashState.error.isNotEmpty()) {
-                logText += "\n${flashState.error}\n"
-            } else if (flashState.isCompleted) {
-                logText += "\n${context.getString(R.string.horizon_flash_complete)}\n\n\n"
-                showFloatAction = true
-            }
-        }
-    }
-
-    val onBack: () -> Unit = {
-        if (!flashState.isFlashing || flashState.isCompleted || flashState.error.isNotEmpty()) {
-            // 清理全局状态
-            if (flashState.isCompleted || flashState.error.isNotEmpty()) {
-                KernelFlashStateHolder.currentState = null
-                KernelFlashStateHolder.currentUri = null
-                KernelFlashStateHolder.currentSlot = null
-                KernelFlashStateHolder.isFlashing = false
-            }
-            navigator.popBackStack()
-        }
-    }
-
-    BackHandler(enabled = true) {
-        onBack()
-    }
-
-    Scaffold(
-        topBar = {
-            TopBar(
-                flashState = flashState,
-                onBack = onBack,
-                onSave = {
-                    scope.launch {
-                        val format = SimpleDateFormat("yyyy-MM-dd-HH-mm-ss", Locale.getDefault())
-                        val date = format.format(Date())
-                        val file = File(
-                            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
-                            "KernelSU_kernel_flash_log_${date}.log"
-                        )
-                        file.writeText(logContent.toString())
-                        snackBarHost.showSnackbar(logSavedString.format(file.absolutePath))
-                    }
-                },
-                scrollBehavior = scrollBehavior
-            )
-        },
-        floatingActionButton = {
-            if (showFloatAction) {
-                ExtendedFloatingActionButton(
-                    onClick = {
-                        scope.launch {
-                            withContext(Dispatchers.IO) {
-                                reboot()
-                            }
-                        }
-                    },
-                    icon = {
-                        Icon(
-                            Icons.Filled.Refresh,
-                            contentDescription = stringResource(id = R.string.reboot)
-                        )
-                    },
-                    text = {
-                        Text(text = stringResource(id = R.string.reboot))
-                    },
-                    containerColor = MaterialTheme.colorScheme.secondaryContainer,
-                    contentColor = MaterialTheme.colorScheme.onSecondaryContainer,
-                    expanded = true
-                )
-            }
-        },
-        snackbarHost = { SnackbarHost(hostState = snackBarHost) },
-        contentWindowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
-        containerColor = MaterialTheme.colorScheme.background
-    ) { innerPadding ->
-        KeyEventBlocker {
-            it.key == Key.VolumeDown || it.key == Key.VolumeUp
-        }
-
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(innerPadding)
-                .nestedScroll(scrollBehavior.nestedScrollConnection),
-        ) {
-            FlashProgressIndicator(flashState)
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .weight(1f)
-                    .verticalScroll(scrollState)
-            ) {
-                LaunchedEffect(logText) {
-                    scrollState.animateScrollTo(scrollState.maxValue)
-                }
-                Text(
-                    modifier = Modifier.padding(16.dp),
-                    text = logText,
-                    style = MaterialTheme.typography.bodyMedium,
-                    fontFamily = FontFamily.Monospace,
-                    color = MaterialTheme.colorScheme.onSurface
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun FlashProgressIndicator(flashState: com.sukisu.ultra.flash.FlashState) {
-    val progressColor = when {
-        flashState.error.isNotEmpty() -> MaterialTheme.colorScheme.error
-        flashState.isCompleted -> MaterialTheme.colorScheme.tertiary
-        else -> MaterialTheme.colorScheme.primary
-    }
-
-    val progress = animateFloatAsState(
-        targetValue = flashState.progress,
-        label = "FlashProgress"
-    )
-
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(16.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = MaterialTheme.colorScheme.surfaceVariant
-        )
-    ) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp)
-        ) {
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween
-            ) {
-                Text(
-                    text = when {
-                        flashState.error.isNotEmpty() -> stringResource(R.string.flash_failed)
-                        flashState.isCompleted -> stringResource(R.string.flash_success)
-                        else -> stringResource(R.string.flashing)
-                    },
-                    style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold,
-                    color = progressColor
-                )
-
-                when {
-                    flashState.error.isNotEmpty() -> {
-                        Icon(
-                            imageVector = Icons.Default.Error,
-                            contentDescription = null,
-                            tint = MaterialTheme.colorScheme.error
-                        )
-                    }
-                    flashState.isCompleted -> {
-                        Icon(
-                            imageVector = Icons.Default.CheckCircle,
-                            contentDescription = null,
-                            tint = MaterialTheme.colorScheme.tertiary
-                        )
-                    }
-                }
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            if (flashState.currentStep.isNotEmpty()) {
-                Text(
-                    text = flashState.currentStep,
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-
-                Spacer(modifier = Modifier.height(8.dp))
-            }
-
-            LinearProgressIndicator(
-                progress = { progress.value },
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .height(8.dp),
-                color = progressColor,
-                trackColor = MaterialTheme.colorScheme.surfaceVariant
-            )
-
-            if (flashState.error.isNotEmpty()) {
-                Spacer(modifier = Modifier.height(8.dp))
-
-                Row(
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Icon(
-                        imageVector = Icons.Default.Error,
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.error,
-                        modifier = Modifier.size(16.dp)
-                    )
-                }
-
-                Spacer(modifier = Modifier.height(4.dp))
-
-                Text(
-                    text = flashState.error,
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.error,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(
-                            MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f),
-                            shape = MaterialTheme.shapes.small
-                        )
-                        .padding(8.dp)
-                )
-            }
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun TopBar(
-    flashState: com.sukisu.ultra.flash.FlashState,
-    onBack: () -> Unit,
-    onSave: () -> Unit = {},
-    scrollBehavior: TopAppBarScrollBehavior? = null
-) {
-    val statusColor = when {
-        flashState.error.isNotEmpty() -> MaterialTheme.colorScheme.error
-        flashState.isCompleted -> MaterialTheme.colorScheme.tertiary
-        else -> MaterialTheme.colorScheme.primary
-    }
-
-    val colorScheme = MaterialTheme.colorScheme
-    val cardColor = if (CardConfig.isCustomBackgroundEnabled) {
-        colorScheme.surfaceContainerLow
-    } else {
-        colorScheme.background
-    }
-    val cardAlpha = CardConfig.cardAlpha
-
-    TopAppBar(
-        title = {
-            Text(
-                text = stringResource(
-                    when {
-                        flashState.error.isNotEmpty() -> R.string.flash_failed
-                        flashState.isCompleted -> R.string.flash_success
-                        else -> R.string.kernel_flashing
-                    }
-                ),
-                style = MaterialTheme.typography.titleLarge,
-                color = statusColor
-            )
-        },
-        navigationIcon = {
-            IconButton(onClick = onBack) {
-                Icon(
-                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onSurface
-                )
-            }
-        },
-        colors = TopAppBarDefaults.topAppBarColors(
-            containerColor = cardColor.copy(alpha = cardAlpha),
-            scrolledContainerColor = cardColor.copy(alpha = cardAlpha)
-        ),
-        actions = {
-            IconButton(onClick = onSave) {
-                Icon(
-                    imageVector = Icons.Filled.Save,
-                    contentDescription = stringResource(id = R.string.save_log),
-                    tint = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-        },
-        windowInsets = WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
-        scrollBehavior = scrollBehavior
-    )
-}