Build KernelSU as LKM (#1254)

Co-authored-by: weishu <twsxtd@gmail.com>
2024-03-15 18:53:24 +08:00
parent e3998c0744
commit 7568d55be1
27 changed files with 1091 additions and 202 deletions
--- a/manager/app/src/main/java/me/weishu/kernelsu/Kernels.kt
+++ b/manager/app/src/main/java/me/weishu/kernelsu/Kernels.kt
@@ -37,6 +37,23 @@ fun parseKernelVersion(version: String): KernelVersion {
    }
 }

+fun parseKMI(input: String): String? {
+    val regex = Regex("(.* )?(\\d+\\.\\d+)(\\S+)?(android\\d+)(.*)")
+    val result = regex.find(input)
+
+    return result?.let {
+        val androidVersion = it.groups[4]?.value ?: ""
+        val kernelVersion = it.groups[2]?.value ?: ""
+        "$androidVersion-$kernelVersion"
+    }
+}
+
+fun getKMI(): String? {
+    Os.uname().release.let {
+        return parseKMI(it)
+    }
+}
+
 fun getKernelVersion(): KernelVersion {
    Os.uname().release.let {
        return parseKernelVersion(it)
--- a/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Flash.kt
+++ b/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Flash.kt
@@ -0,0 +1,189 @@
+package me.weishu.kernelsu.ui.screen
+
+import android.net.Uri
+import android.os.Environment
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowBack
+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.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.ramcosta.composedestinations.annotation.Destination
+import com.ramcosta.composedestinations.navigation.DestinationsNavigator
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.parcelize.Parcelize
+import me.weishu.kernelsu.R
+import me.weishu.kernelsu.ui.component.KeyEventBlocker
+import me.weishu.kernelsu.ui.util.LocalSnackbarHost
+import me.weishu.kernelsu.ui.util.installBoot
+import me.weishu.kernelsu.ui.util.installModule
+import me.weishu.kernelsu.ui.util.reboot
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.*
+
+/**
+ * @author weishu
+ * @date 2023/1/1.
+ */
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+@Destination
+fun FlashScreen(navigator: DestinationsNavigator, flashIt: FlashIt) {
+
+    var text by rememberSaveable { mutableStateOf("") }
+    val logContent = rememberSaveable { StringBuilder() }
+    var showFloatAction by rememberSaveable { mutableStateOf(false) }
+
+    val snackBarHost = LocalSnackbarHost.current
+    val scope = rememberCoroutineScope()
+    val scrollState = rememberScrollState()
+
+    LaunchedEffect(Unit) {
+        if (text.isNotEmpty()) {
+            return@LaunchedEffect
+        }
+        withContext(Dispatchers.IO) {
+            flashIt(flashIt, onFinish = { showReboot ->
+                if (showReboot) {
+                    showFloatAction = true
+                }
+            }, onStdout = {
+                text += "$it\n"
+                logContent.append(it).append("\n")
+            }, onStderr = {
+                logContent.append(it).append("\n")
+            });
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            TopBar(
+                onBack = {
+                    navigator.popBackStack()
+                },
+                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_install_log_${date}.log"
+                        )
+                        file.writeText(logContent.toString())
+                        snackBarHost.showSnackbar("Log saved to ${file.absolutePath}")
+                    }
+                }
+            )
+        },
+        floatingActionButton = {
+            if (showFloatAction) {
+                val reboot = stringResource(id = R.string.reboot)
+                ExtendedFloatingActionButton(
+                    onClick = {
+                        scope.launch {
+                            withContext(Dispatchers.IO) {
+                                reboot()
+                            }
+                        }
+                    },
+                    icon = { Icon(Icons.Filled.Refresh, reboot) },
+                    text = { Text(text = reboot) },
+                )
+            }
+
+        }
+    ) { innerPadding ->
+        KeyEventBlocker {
+            it.key == Key.VolumeDown || it.key == Key.VolumeUp
+        }
+        Column(
+            modifier = Modifier
+                .fillMaxSize(1f)
+                .padding(innerPadding)
+                .verticalScroll(scrollState),
+        ) {
+            LaunchedEffect(text) {
+                scrollState.animateScrollTo(scrollState.maxValue)
+            }
+            Text(
+                modifier = Modifier.padding(8.dp),
+                text = text,
+                fontSize = MaterialTheme.typography.bodySmall.fontSize,
+                fontFamily = FontFamily.Monospace,
+                lineHeight = MaterialTheme.typography.bodySmall.lineHeight,
+            )
+        }
+    }
+}
+
+@Parcelize
+sealed class FlashIt : Parcelable {
+    data class FlashBoot(val bootUri: Uri? = null, val koUri: Uri, val ota: Boolean) : FlashIt()
+
+    data class FlashModule(val uri: Uri) : FlashIt()
+}
+
+fun flashIt(
+    flashIt: FlashIt, onFinish: (Boolean) -> Unit,
+    onStdout: (String) -> Unit,
+    onStderr: (String) -> Unit
+) {
+    when (flashIt) {
+        is FlashIt.FlashBoot -> installBoot(
+            flashIt.bootUri,
+            flashIt.koUri,
+            flashIt.ota,
+            onFinish,
+            onStdout,
+            onStderr
+        )
+
+        is FlashIt.FlashModule -> installModule(flashIt.uri, onFinish, onStdout, onStderr)
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun TopBar(onBack: () -> Unit = {}, onSave: () -> Unit = {}) {
+    TopAppBar(
+        title = { Text(stringResource(R.string.install)) },
+        navigationIcon = {
+            IconButton(
+                onClick = onBack
+            ) { Icon(Icons.Filled.ArrowBack, contentDescription = null) }
+        },
+        actions = {
+            IconButton(onClick = onSave) {
+                Icon(
+                    imageVector = Icons.Filled.Save,
+                    contentDescription = "Localized description"
+                )
+            }
+        }
+    )
+}
+
+@Preview
+@Composable
+fun InstallPreview() {
+//    InstallScreen(DestinationsNavigator(), uri = Uri.EMPTY)
+}
--- a/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Home.kt
+++ b/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Home.kt
@@ -34,6 +34,7 @@ import kotlinx.coroutines.withContext
 import me.weishu.kernelsu.*
 import me.weishu.kernelsu.R
 import me.weishu.kernelsu.ui.component.rememberConfirmDialog
+import me.weishu.kernelsu.ui.screen.destinations.InstallScreenDestination
 import me.weishu.kernelsu.ui.screen.destinations.SettingScreenDestination
 import me.weishu.kernelsu.ui.util.*

@@ -60,7 +61,9 @@ fun HomeScreen(navigator: DestinationsNavigator) {
            }
            val ksuVersion = if (isManager) Natives.version else null

-            StatusCard(kernelVersion, ksuVersion)
+            StatusCard(kernelVersion, ksuVersion) {
+                navigator.navigate(InstallScreenDestination)
+            }
            if (isManager && Natives.requireNewKernel()) {
                WarningCard(
                    stringResource(id = R.string.require_kernel_version).format(
@@ -68,7 +71,7 @@ fun HomeScreen(navigator: DestinationsNavigator) {
                    )
                )
            }
-            if (!rootAvailable()) {
+            if (ksuVersion != null && !rootAvailable()) {
                WarningCard(
                    stringResource(id = R.string.grant_root_failed)
                )
@@ -174,7 +177,7 @@ private fun TopBar(onSettingsClick: () -> Unit) {
 }

@Composable
-private fun StatusCard(kernelVersion: KernelVersion, ksuVersion: Int?) {
+private fun StatusCard(kernelVersion: KernelVersion, ksuVersion: Int?, onClickInstall: () -> Unit = {}) {
    ElevatedCard(
        colors = CardDefaults.elevatedCardColors(containerColor = run {
            if (ksuVersion != null) MaterialTheme.colorScheme.secondaryContainer
@@ -185,8 +188,8 @@ private fun StatusCard(kernelVersion: KernelVersion, ksuVersion: Int?) {
        Row(modifier = Modifier
            .fillMaxWidth()
            .clickable {
-                if (kernelVersion.isGKI() && ksuVersion == null) {
-                    uriHandler.openUri("https://kernelsu.org/guide/installation.html")
+                if (kernelVersion.isGKI()) {
+                    onClickInstall()
                }
            }
            .padding(24.dp), verticalAlignment = Alignment.CenterVertically) {
--- a/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Install.kt
+++ b/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Install.kt
@@ -1,140 +1,262 @@
 package me.weishu.kernelsu.ui.screen

+import android.app.Activity
+import android.content.Intent
 import android.net.Uri
-import android.os.Environment
+import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowBack
-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.ExperimentalComposeUiApi
+import androidx.compose.material3.Button
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.input.key.Key
-import androidx.compose.ui.input.key.key
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import com.ramcosta.composedestinations.annotation.Destination
 import com.ramcosta.composedestinations.navigation.DestinationsNavigator
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import me.weishu.kernelsu.R
-import me.weishu.kernelsu.ui.component.KeyEventBlocker
-import me.weishu.kernelsu.ui.util.LocalSnackbarHost
-import me.weishu.kernelsu.ui.util.installModule
-import me.weishu.kernelsu.ui.util.reboot
-import java.io.File
-import java.text.SimpleDateFormat
-import java.util.*
+import me.weishu.kernelsu.ui.component.rememberConfirmDialog
+import me.weishu.kernelsu.ui.component.rememberLoadingDialog
+import me.weishu.kernelsu.ui.screen.destinations.FlashScreenDestination
+import me.weishu.kernelsu.ui.util.DownloadListener
+import me.weishu.kernelsu.ui.util.download
+import me.weishu.kernelsu.ui.util.getLKMUrl
+import me.weishu.kernelsu.ui.util.isAbDevice
+import me.weishu.kernelsu.ui.util.rootAvailable

 /**
 * @author weishu
- * @date 2023/1/1.
+ * @date 2024/3/12.
 */
-@OptIn(ExperimentalComposeUiApi::class)
-@Composable
@Destination
-fun InstallScreen(navigator: DestinationsNavigator, uri: Uri) {
-
-    var text by rememberSaveable { mutableStateOf("") }
-    val logContent = rememberSaveable { StringBuilder() }
-    var showFloatAction by rememberSaveable { mutableStateOf(false) }
-
-    val snackBarHost = LocalSnackbarHost.current
+@Composable
+fun InstallScreen(navigator: DestinationsNavigator) {
    val scope = rememberCoroutineScope()
-    val scrollState = rememberScrollState()
+    val loadingDialog = rememberLoadingDialog()
+    val context = LocalContext.current
+    var installMethod by remember {
+        mutableStateOf<InstallMethod?>(null)
+    }

-    LaunchedEffect(Unit) {
-        if (text.isNotEmpty()) {
-            return@LaunchedEffect
-        }
-        withContext(Dispatchers.IO) {
-            installModule(uri, onFinish = { success ->
-                if (success) {
-                    showFloatAction = true
+    val onFileDownloaded = { uri: Uri ->
+
+        installMethod?.let {
+            scope.launch(Dispatchers.Main) {
+                when (it) {
+                    InstallMethod.DirectInstall -> {
+                        navigator.navigate(
+                            FlashScreenDestination(
+                                FlashIt.FlashBoot(
+                                    null,
+                                    uri,
+                                    false
+                                )
+                            )
+                        )
+                    }
+
+                    InstallMethod.DirectInstallToInactiveSlot -> {
+                        navigator.navigate(
+                            FlashScreenDestination(
+                                FlashIt.FlashBoot(
+                                    null,
+                                    uri,
+                                    true
+                                )
+                            )
+                        )
+                    }
+
+                    is InstallMethod.SelectFile -> {
+                        navigator.navigate(
+                            FlashScreenDestination(
+                                FlashIt.FlashBoot(
+                                    it.uri,
+                                    uri,
+                                    false
+                                )
+                            )
+                        )
+                    }
                }
-            }, onStdout = {
-                text += "$it\n"
-                logContent.append(it).append("\n")
-            }, onStderr = {
-                logContent.append(it).append("\n")
-            });
+            }
        }
    }

-    Scaffold(
-        topBar = {
-            TopBar(
-                onBack = {
-                    navigator.popBackStack()
-                },
-                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_install_log_${date}.log"
-                        )
-                        file.writeText(logContent.toString())
-                        snackBarHost.showSnackbar("Log saved to ${file.absolutePath}")
-                    }
+    Scaffold(topBar = {
+        TopBar {
+            navigator.popBackStack()
+        }
+    }) {
+        Column(modifier = Modifier.padding(it)) {
+            SelectInstallMethod { method ->
+                installMethod = method
+            }
+
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(16.dp)
+            ) {
+
+                DownloadListener(context = context) { uri ->
+                    onFileDownloaded(uri)
+                    loadingDialog.hide()
                }
-            )
-        },
-        floatingActionButton = {
-            if (showFloatAction) {
-                val reboot = stringResource(id = R.string.reboot)
-                ExtendedFloatingActionButton(
+                Button(
+                    modifier = Modifier.fillMaxWidth(),
+                    enabled = installMethod != null,
                    onClick = {
-                        scope.launch {
-                            withContext(Dispatchers.IO) {
-                                reboot()
+                        loadingDialog.showLoading()
+                        scope.launch(Dispatchers.IO) {
+                            getLKMUrl().onFailure { throwable ->
+                                loadingDialog.hide()
+                                scope.launch(Dispatchers.Main) {
+                                    Toast.makeText(
+                                        context,
+                                        "Failed to fetch LKM url: ${throwable.message}",
+                                        Toast.LENGTH_SHORT
+                                    ).show()
+                                }
+                            }.onSuccess { result ->
+                                loadingDialog.hide()
+
+                                download(
+                                    context = context,
+                                    url = result.second,
+                                    fileName = result.first,
+                                    description = "Downloading ${result.first}",
+                                    onDownloaded = { uri ->
+                                        onFileDownloaded(uri)
+                                        loadingDialog.hide()
+                                    },
+                                    onDownloading = {}
+                                )
                            }
                        }
-                    },
-                    icon = { Icon(Icons.Filled.Refresh, reboot) },
-                    text = { Text(text = reboot) },
+                    }) {
+                    Text("Next", fontSize = MaterialTheme.typography.bodyMedium.fontSize)
+                }
+            }
+        }
+    }
+}
+
+sealed class InstallMethod {
+    data class SelectFile(val uri: Uri? = null, override val label: Int = R.string.select_file) :
+        InstallMethod()
+
+    object DirectInstall : InstallMethod() {
+        override val label: Int
+            get() = R.string.direct_install
+    }
+
+    object DirectInstallToInactiveSlot : InstallMethod() {
+        override val label: Int
+            get() = R.string.install_inactive_slot
+    }
+
+    abstract val label: Int
+}
+
+@Composable
+private fun SelectInstallMethod(onSelected: (InstallMethod) -> Unit = {}) {
+    val rootAvailable = rootAvailable()
+    val isAbDevice = isAbDevice()
+    val radioOptions = mutableListOf<InstallMethod>(InstallMethod.SelectFile())
+    if (rootAvailable) {
+        radioOptions.add(InstallMethod.DirectInstall)
+
+        if (isAbDevice) {
+            radioOptions.add(InstallMethod.DirectInstallToInactiveSlot)
+        }
+    }
+
+    var selectedOption by remember { mutableStateOf<InstallMethod?>(null) }
+    val selectImageLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.StartActivityForResult()
+    ) {
+        if (it.resultCode == Activity.RESULT_OK) {
+            it.data?.data?.let { uri ->
+                val option = InstallMethod.SelectFile(uri)
+                selectedOption = option
+                onSelected(option)
+            }
+        }
+    }
+
+    val confirmDialog = rememberConfirmDialog(onConfirm = {
+        selectedOption = InstallMethod.DirectInstallToInactiveSlot
+        onSelected(InstallMethod.DirectInstallToInactiveSlot)
+    }, onDismiss = null)
+    val dialogTitle = stringResource(id = android.R.string.dialog_alert_title)
+    val dialogContent = stringResource(id = R.string.install_inactive_slot_warning)
+
+    val onClick = { option: InstallMethod ->
+
+        when (option) {
+            is InstallMethod.SelectFile -> {
+                selectImageLauncher.launch(
+                    Intent(Intent.ACTION_GET_CONTENT).apply {
+                        type = "application/octet-stream"
+                    }
                )
            }

-        }
-    ) { innerPadding ->
-        KeyEventBlocker {
-            it.key == Key.VolumeDown || it.key == Key.VolumeUp
-        }
-        Column(
-            modifier = Modifier
-                .fillMaxSize(1f)
-                .padding(innerPadding)
-                .verticalScroll(scrollState),
-        ) {
-            LaunchedEffect(text) {
-                scrollState.animateScrollTo(scrollState.maxValue)
+            is InstallMethod.DirectInstall -> {
+                selectedOption = option
+                onSelected(option)
+            }
+            is InstallMethod.DirectInstallToInactiveSlot -> {
+                confirmDialog.showConfirm(dialogTitle, dialogContent)
+            }
+        }
+    }
+
+    Column {
+        radioOptions.forEach { option ->
+            Row(verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .clickable {
+                        onClick(option)
+                    }) {
+                RadioButton(selected = option.javaClass == selectedOption?.javaClass, onClick = {
+                    onClick(option)
+                })
+                Text(text = stringResource(id = option.label))
            }
-            Text(
-                modifier = Modifier.padding(8.dp),
-                text = text,
-                fontSize = MaterialTheme.typography.bodySmall.fontSize,
-                fontFamily = FontFamily.Monospace,
-                lineHeight = MaterialTheme.typography.bodySmall.lineHeight,
-            )
        }
    }
 }

@OptIn(ExperimentalMaterial3Api::class)
@Composable
-private fun TopBar(onBack: () -> Unit = {}, onSave: () -> Unit = {}) {
+private fun TopBar(onBack: () -> Unit = {}) {
    TopAppBar(
        title = { Text(stringResource(R.string.install)) },
        navigationIcon = {
@@ -142,19 +264,11 @@ private fun TopBar(onBack: () -> Unit = {}, onSave: () -> Unit = {}) {
                onClick = onBack
            ) { Icon(Icons.Filled.ArrowBack, contentDescription = null) }
        },
-        actions = {
-            IconButton(onClick = onSave) {
-                Icon(
-                    imageVector = Icons.Filled.Save,
-                    contentDescription = "Localized description"
-                )
-            }
-        }
    )
 }

-@Preview
@Composable
-fun InstallPreview() {
-//    InstallScreen(DestinationsNavigator(), uri = Uri.EMPTY)
+@Preview
+fun SelectInstall_Preview() {
+//    InstallScreen(DestinationsNavigator())
 }
--- a/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Module.kt
+++ b/manager/app/src/main/java/me/weishu/kernelsu/ui/screen/Module.kt
@@ -43,7 +43,7 @@ import me.weishu.kernelsu.R
 import me.weishu.kernelsu.ui.component.ConfirmResult
 import me.weishu.kernelsu.ui.component.rememberConfirmDialog
 import me.weishu.kernelsu.ui.component.rememberLoadingDialog
-import me.weishu.kernelsu.ui.screen.destinations.InstallScreenDestination
+import me.weishu.kernelsu.ui.screen.destinations.FlashScreenDestination
 import me.weishu.kernelsu.ui.screen.destinations.WebScreenDestination
 import me.weishu.kernelsu.ui.util.*
 import me.weishu.kernelsu.ui.viewmodel.ModuleViewModel
@@ -81,7 +81,7 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                val data = it.data ?: return@rememberLauncherForActivityResult
                val uri = data.data ?: return@rememberLauncherForActivityResult

-                navigator.navigate(InstallScreenDestination(uri))
+                navigator.navigate(FlashScreenDestination(FlashIt.FlashModule(uri)))

                viewModel.markNeedRefresh()

@@ -123,7 +123,7 @@ fun ModuleScreen(navigator: DestinationsNavigator) {
                        .fillMaxSize(),
                    onInstallModule =
                    {
-                        navigator.navigate(InstallScreenDestination(it))
+                        navigator.navigate(FlashScreenDestination(FlashIt.FlashModule(it)))
                    }, onClickModule = { id, name, hasWebUi ->
                        if (hasWebUi) {
                            navigator.navigate(WebScreenDestination(id, name))
--- a/manager/app/src/main/java/me/weishu/kernelsu/ui/util/Downloader.kt
+++ b/manager/app/src/main/java/me/weishu/kernelsu/ui/util/Downloader.kt
@@ -10,6 +10,7 @@ import android.net.Uri
 import android.os.Environment
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
+import me.weishu.kernelsu.getKMI

 /**
 * @author weishu
@@ -94,6 +95,38 @@ fun checkNewVersion(): Triple<Int, String, String> {
    }
    return defaultValue
 }
+fun getLKMUrl(): Result<Pair<String, String>> {
+    val url = "https://api.github.com/repos/tiann/KernelSU/releases/latest"
+
+    val kmi = getKMI() ?: return Result.failure(RuntimeException("Get KMI failed"))
+    runCatching {
+        okhttp3.OkHttpClient().newCall(okhttp3.Request.Builder().url(url).build()).execute()
+            .use { response ->
+                val body = response.body?.string() ?: return Result.failure(RuntimeException("request body failed"))
+                if (!response.isSuccessful) {
+                    return Result.failure(RuntimeException("Request failed, code: ${response.code}, message: $body"))
+                }
+                val json = org.json.JSONObject(body)
+
+                val assets = json.getJSONArray("assets")
+                for (i in 0 until assets.length()) {
+                    val asset = assets.getJSONObject(i)
+                    val name = asset.getString("name")
+                    if (!name.endsWith(".ko")) {
+                        continue
+                    }
+
+                    if (name.contains(kmi)) {
+                        return Result.success(Pair(name, asset.getString("browser_download_url")))
+                    }
+                }
+            }
+    }.onFailure {
+        return Result.failure(it)
+    }
+
+    return Result.failure(RuntimeException("Cannot find LKM for $kmi"))
+}

@Composable
 fun DownloadListener(context: Context, onDownloaded: (Uri) -> Unit) {
--- a/manager/app/src/main/java/me/weishu/kernelsu/ui/util/KsuCli.kt
+++ b/manager/app/src/main/java/me/weishu/kernelsu/ui/util/KsuCli.kt
@@ -1,6 +1,7 @@
 package me.weishu.kernelsu.ui.util

 import android.net.Uri
+import android.os.Environment
 import android.os.SystemClock
 import android.util.Log
 import com.topjohnwu.superuser.CallbackList
@@ -138,6 +139,84 @@ fun installModule(
    }
 }

+fun installBoot(
+    bootUri: Uri?,
+    lkmUri: Uri,
+    ota: Boolean,
+    onFinish: (Boolean) -> Unit,
+    onStdout: (String) -> Unit,
+    onStderr: (String) -> Unit
+): Boolean {
+    val resolver = ksuApp.contentResolver
+
+    with(resolver.openInputStream(lkmUri)) {
+        val lkmFile = File(ksuApp.cacheDir, "kernelsu.ko")
+        lkmFile.outputStream().use { output ->
+            this?.copyTo(output)
+        }
+
+        if (!lkmFile.exists()) {
+            onStdout("- kernelsu.ko not found")
+            onFinish(false)
+            return false
+        }
+
+        val bootFile = bootUri?.let { uri ->
+            with(resolver.openInputStream(uri)) {
+                val bootFile = File(ksuApp.cacheDir, "boot.img")
+                bootFile.outputStream().use { output ->
+                    this?.copyTo(output)
+                }
+
+                bootFile
+            }
+        }
+
+        val magiskboot = File(ksuApp.applicationInfo.nativeLibraryDir, "libmagiskboot.so")
+        var cmd = "boot-patch -m ${lkmFile.absolutePath} --magiskboot ${magiskboot.absolutePath}"
+
+        cmd += if (bootFile == null) {
+            // no boot.img, use -f to force install
+            " -f"
+        } else {
+            " -b ${bootFile.absolutePath}"
+        }
+
+        if (ota) {
+            cmd += " -u"
+        }
+
+        // output dir
+        val downloadsDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
+        cmd += " -o $downloadsDir"
+
+        val shell = createRootShell()
+
+        val stdoutCallback: CallbackList<String?> = object : CallbackList<String?>() {
+            override fun onAddElement(s: String?) {
+                onStdout(s ?: "")
+            }
+        }
+
+        val stderrCallback: CallbackList<String?> = object : CallbackList<String?>() {
+            override fun onAddElement(s: String?) {
+                onStderr(s ?: "")
+            }
+        }
+
+        val result =
+            shell.newJob().add("${getKsuDaemonPath()} $cmd").to(stdoutCallback, stderrCallback)
+                .exec()
+        Log.i("KernelSU", "install boot $lkmUri result: $result")
+
+        lkmFile.delete()
+        bootFile?.delete()
+
+        onFinish(bootUri != null && result.isSuccess)
+        return result.isSuccess
+    }
+}
+
 fun reboot(reason: String = "") {
    val shell = getRootShell()
    if (reason == "recovery") {
@@ -152,6 +231,11 @@ fun rootAvailable(): Boolean {
    return shell.isRoot
 }

+fun isAbDevice(): Boolean {
+    val shell = getRootShell()
+    return ShellUtils.fastCmd(shell, "getprop ro.build.ab_update").trim().toBoolean()
+}
+
 fun overlayFsAvailable(): Boolean {
    val shell = getRootShell()
    // check /proc/filesystems