diff --git a/.gitignore b/.gitignore index 98ccb8c50..006b3d35b 100644 --- a/.gitignore +++ b/.gitignore @@ -12,3 +12,7 @@ native/out # Android Studio *.iml .idea +.cursor +ramdisk.img +app/core/src/debug +app/core/src/release diff --git a/app/apk-ng/build.gradle.kts b/app/apk-ng/build.gradle.kts new file mode 100644 index 000000000..4d38c63bc --- /dev/null +++ b/app/apk-ng/build.gradle.kts @@ -0,0 +1,61 @@ +plugins { + id("com.android.application") + kotlin("plugin.parcelize") + kotlin("plugin.compose") + kotlin("plugin.serialization") +} + +setupMainApk() + +android { + buildFeatures { + compose = true + } + + compileOptions { + isCoreLibraryDesugaringEnabled = true + } + + packaging { + jniLibs { + excludes += "lib/*/libandroidx.graphics.path.so" + } + } + + defaultConfig { + proguardFile("proguard-rules.pro") + } + + buildTypes { + release { + isMinifyEnabled = true + isShrinkResources = true + } + } +} + +dependencies { + implementation(project(":core")) + coreLibraryDesugaring(libs.jdk.libs) + + implementation(libs.appcompat) + implementation(libs.material) + + // Compose + implementation(platform(libs.compose.bom)) + implementation(libs.compose.ui) + implementation(libs.compose.ui.tooling.preview) + debugImplementation(libs.compose.ui.tooling) + implementation(libs.activity.compose) + implementation(libs.lifecycle.runtime.compose) + implementation(libs.lifecycle.viewmodel.compose) + implementation(libs.miuix) + implementation(libs.miuix.icons) + implementation(libs.miuix.navigation3.ui) + + // Navigation3 + implementation(libs.navigation3.runtime) + implementation(libs.navigationevent.compose) + implementation(libs.lifecycle.viewmodel.navigation3) + +} diff --git a/app/apk-ng/proguard-rules.pro b/app/apk-ng/proguard-rules.pro new file mode 100644 index 000000000..105abd009 --- /dev/null +++ b/app/apk-ng/proguard-rules.pro @@ -0,0 +1,3 @@ +# Excessive obfuscation +-flattenpackagehierarchy +-allowaccessmodification diff --git a/app/apk-ng/src/main/AndroidManifest.xml b/app/apk-ng/src/main/AndroidManifest.xml new file mode 100644 index 000000000..579f4f422 --- /dev/null +++ b/app/apk-ng/src/main/AndroidManifest.xml @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/AsyncLoadViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/AsyncLoadViewModel.kt new file mode 100644 index 000000000..79bcfcab8 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/AsyncLoadViewModel.kt @@ -0,0 +1,27 @@ +package com.topjohnwu.magisk.arch + +import androidx.annotation.MainThread +import androidx.lifecycle.viewModelScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.launch + +abstract class AsyncLoadViewModel : BaseViewModel() { + + private var loadingJob: Job? = null + + @MainThread + fun startLoading() { + if (loadingJob?.isActive == true) { + return + } + loadingJob = viewModelScope.launch { doLoadWork() } + } + + @MainThread + fun reload() { + loadingJob?.cancel() + loadingJob = viewModelScope.launch { doLoadWork() } + } + + protected abstract suspend fun doLoadWork() +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/BaseViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/BaseViewModel.kt new file mode 100644 index 000000000..f3adea422 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/BaseViewModel.kt @@ -0,0 +1,32 @@ +package com.topjohnwu.magisk.arch + +import android.os.Bundle +import android.widget.Toast +import androidx.annotation.StringRes +import androidx.lifecycle.ViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.ktx.toast +import com.topjohnwu.magisk.ui.navigation.Route +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.SharedFlow + +abstract class BaseViewModel : ViewModel() { + + private val _navEvents = MutableSharedFlow(extraBufferCapacity = 1) + val navEvents: SharedFlow = _navEvents + + open fun onSaveState(state: Bundle) {} + open fun onRestoreState(state: Bundle) {} + + fun showSnackbar(@StringRes resId: Int) { + AppContext.toast(resId, Toast.LENGTH_SHORT) + } + + fun showSnackbar(msg: String) { + AppContext.toast(msg, Toast.LENGTH_SHORT) + } + + fun navigateTo(route: Route) { + _navEvents.tryEmit(route) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/ViewModelFactory.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/ViewModelFactory.kt new file mode 100644 index 000000000..5da9deddf --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/arch/ViewModelFactory.kt @@ -0,0 +1,26 @@ +package com.topjohnwu.magisk.arch + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.ViewModelProvider +import com.topjohnwu.magisk.core.di.ServiceLocator +import com.topjohnwu.magisk.ui.home.HomeViewModel +import com.topjohnwu.magisk.ui.install.InstallViewModel +import com.topjohnwu.magisk.ui.log.LogViewModel +import com.topjohnwu.magisk.ui.superuser.SuperuserViewModel +import com.topjohnwu.magisk.ui.surequest.SuRequestViewModel + +object VMFactory : ViewModelProvider.Factory { + @Suppress("UNCHECKED_CAST") + override fun create(modelClass: Class): T { + return when (modelClass) { + HomeViewModel::class.java -> HomeViewModel(ServiceLocator.networkService) + LogViewModel::class.java -> LogViewModel(ServiceLocator.logRepo) + SuperuserViewModel::class.java -> SuperuserViewModel(ServiceLocator.policyDB) + InstallViewModel::class.java -> + InstallViewModel(ServiceLocator.networkService) + SuRequestViewModel::class.java -> + SuRequestViewModel(ServiceLocator.policyDB, ServiceLocator.timeoutPrefs) + else -> modelClass.newInstance() + } as T + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalBuffer.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalBuffer.kt new file mode 100644 index 000000000..56b541273 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalBuffer.kt @@ -0,0 +1,452 @@ +package com.topjohnwu.magisk.terminal + +import java.util.Arrays + +/** + * A circular buffer of [TerminalRow]s which keeps notes about what is visible on a logical screen and the scroll + * history. + * + * See [externalToInternalRow] for how to map from logical screen rows to array indices. + */ +class TerminalBuffer(columns: Int, totalRows: Int, screenRows: Int) { + + var lines: Array + + /** The length of [lines]. */ + var totalRows: Int = totalRows + private set + + /** The number of rows and columns visible on the screen. */ + var screenRows: Int = screenRows + + var columns: Int = columns + + /** The number of rows kept in history. */ + var activeTranscriptRows: Int = 0 + private set + + /** The index in the circular buffer where the visible screen starts. */ + private var screenFirstRow = 0 + + init { + lines = arrayOfNulls(totalRows) + blockSet(0, 0, columns, screenRows, ' '.code, TextStyle.NORMAL) + } + + val transcriptText: String + get() = getSelectedText(0, -activeTranscriptRows, columns, screenRows).trim() + + val transcriptTextWithoutJoinedLines: String + get() = getSelectedText(0, -activeTranscriptRows, columns, screenRows, false).trim() + + val transcriptTextWithFullLinesJoined: String + get() = getSelectedText(0, -activeTranscriptRows, columns, screenRows, joinBackLines = true, joinFullLines = true).trim() + + fun getSelectedText(selX1: Int, selY1: Int, selX2: Int, selY2: Int, joinBackLines: Boolean = true, joinFullLines: Boolean = false): String { + val builder = StringBuilder() + + var y1 = selY1 + var y2 = selY2 + if (y1 < -activeTranscriptRows) y1 = -activeTranscriptRows + if (y2 >= screenRows) y2 = screenRows - 1 + + for (row in y1..y2) { + val x1 = if (row == y1) selX1 else 0 + var x2: Int + if (row == y2) { + x2 = selX2 + 1 + if (x2 > columns) x2 = columns + } else { + x2 = columns + } + val lineObject = lines[externalToInternalRow(row)]!! + val x1Index = lineObject.findStartOfColumn(x1) + var x2Index = if (x2 < columns) lineObject.findStartOfColumn(x2) else lineObject.spaceUsed + if (x2Index == x1Index) { + x2Index = lineObject.findStartOfColumn(x2 + 1) + } + val line = lineObject.text + var lastPrintingCharIndex = -1 + val rowLineWrap = getLineWrap(row) + if (rowLineWrap && x2 == columns) { + lastPrintingCharIndex = x2Index - 1 + } else { + for (i in x1Index until x2Index) { + val c = line[i] + if (c != ' ') lastPrintingCharIndex = i + } + } + + val len = lastPrintingCharIndex - x1Index + 1 + if (lastPrintingCharIndex != -1 && len > 0) + builder.append(line, x1Index, len) + + val lineFillsWidth = lastPrintingCharIndex == x2Index - 1 + if ((!joinBackLines || !rowLineWrap) && (!joinFullLines || !lineFillsWidth) + && row < y2 && row < screenRows - 1) builder.append('\n') + } + return builder.toString() + } + + fun getWordAtLocation(x: Int, y: Int): String { + var y1 = y + var y2 = y + while (y1 > 0 && !getSelectedText(0, y1 - 1, columns, y, joinBackLines = true, joinFullLines = true).contains("\n")) { + y1-- + } + while (y2 < screenRows && !getSelectedText(0, y, columns, y2 + 1, joinBackLines = true, joinFullLines = true).contains("\n")) { + y2++ + } + + val text = getSelectedText(0, y1, columns, y2, joinBackLines = true, joinFullLines = true) + val textOffset = (y - y1) * columns + x + + if (textOffset >= text.length) { + return "" + } + + val x1 = text.lastIndexOf(' ', textOffset) + var x2 = text.indexOf(' ', textOffset) + if (x2 == -1) { + x2 = text.length + } + + if (x1 == x2) { + return "" + } + return text.substring(x1 + 1, x2) + } + + val activeRows: Int get() = activeTranscriptRows + screenRows + + /** + * Convert a row value from the public external coordinate system to our internal private coordinate system. + * + * ``` + * - External coordinate system: -activeTranscriptRows to screenRows-1, with the screen being 0..screenRows-1. + * - Internal coordinate system: the screenRows lines starting at screenFirstRow comprise the screen, while the + * activeTranscriptRows lines ending at screenFirstRow-1 form the transcript (as a circular buffer). + * + * External <-> Internal: + * + * [ ... ] [ ... ] + * [ -activeTranscriptRows ] [ screenFirstRow - activeTranscriptRows ] + * [ ... ] [ ... ] + * [ 0 (visible screen starts here) ] <-> [ screenFirstRow ] + * [ ... ] [ ... ] + * [ screenRows-1 ] [ screenFirstRow + screenRows-1 ] + * ``` + * + * @param externalRow a row in the external coordinate system. + * @return The row corresponding to the input argument in the private coordinate system. + */ + fun externalToInternalRow(externalRow: Int): Int { + if (externalRow < -activeTranscriptRows || externalRow > screenRows) + throw IllegalArgumentException("extRow=$externalRow, screenRows=$screenRows, activeTranscriptRows=$activeTranscriptRows") + val internalRow = screenFirstRow + externalRow + return if (internalRow < 0) (totalRows + internalRow) else (internalRow % totalRows) + } + + fun setLineWrap(row: Int) { + lines[externalToInternalRow(row)]!!.lineWrap = true + } + + fun getLineWrap(row: Int): Boolean { + return lines[externalToInternalRow(row)]!!.lineWrap + } + + fun clearLineWrap(row: Int) { + lines[externalToInternalRow(row)]!!.lineWrap = false + } + + /** + * Resize the screen which this transcript backs. Currently, this only works if the number of columns does not + * change or the rows expand (that is, it only works when shrinking the number of rows). + * + * @param newColumns The number of columns the screen should have. + * @param newRows The number of rows the screen should have. + * @param cursor An int[2] containing the (column, row) cursor location. + */ + fun resize(newColumns: Int, newRows: Int, newTotalRows: Int, cursor: IntArray, currentStyle: Long, altScreen: Boolean) { + // newRows > totalRows should not normally happen since totalRows is TRANSCRIPT_ROWS (10000): + if (newColumns == columns && newRows <= totalRows) { + // Fast resize where just the rows changed. + var shiftDownOfTopRow = screenRows - newRows + if (shiftDownOfTopRow > 0 && shiftDownOfTopRow < screenRows) { + // Shrinking. Check if we can skip blank rows at bottom below cursor. + for (i in screenRows - 1 downTo 1) { + if (cursor[1] >= i) break + val r = externalToInternalRow(i) + if (lines[r] == null || lines[r]!!.isBlank()) { + if (--shiftDownOfTopRow == 0) break + } + } + } else if (shiftDownOfTopRow < 0) { + // Negative shift down = expanding. Only move screen up if there is transcript to show: + val actualShift = maxOf(shiftDownOfTopRow, -activeTranscriptRows) + if (shiftDownOfTopRow != actualShift) { + for (i in 0 until actualShift - shiftDownOfTopRow) + allocateFullLineIfNecessary((screenFirstRow + screenRows + i) % totalRows).clear(currentStyle) + shiftDownOfTopRow = actualShift + } + } + screenFirstRow += shiftDownOfTopRow + screenFirstRow = if (screenFirstRow < 0) (screenFirstRow + totalRows) else (screenFirstRow % totalRows) + totalRows = newTotalRows + activeTranscriptRows = if (altScreen) 0 else maxOf(0, activeTranscriptRows + shiftDownOfTopRow) + cursor[1] -= shiftDownOfTopRow + screenRows = newRows + } else { + // Copy away old state and update new: + val oldLines = lines + lines = arrayOfNulls(newTotalRows) + for (i in 0 until newTotalRows) + lines[i] = TerminalRow(newColumns, currentStyle) + + val oldActiveTranscriptRows = activeTranscriptRows + val oldScreenFirstRow = screenFirstRow + val oldScreenRows = screenRows + val oldTotalRows = totalRows + totalRows = newTotalRows + screenRows = newRows + activeTranscriptRows = 0 + screenFirstRow = 0 + columns = newColumns + + var newCursorRow = -1 + var newCursorColumn = -1 + val oldCursorRow = cursor[1] + val oldCursorColumn = cursor[0] + var newCursorPlaced = false + + var currentOutputExternalRow = 0 + var currentOutputExternalColumn = 0 + + var skippedBlankLines = 0 + for (externalOldRow in -oldActiveTranscriptRows until oldScreenRows) { + var internalOldRow = oldScreenFirstRow + externalOldRow + internalOldRow = if (internalOldRow < 0) (oldTotalRows + internalOldRow) else (internalOldRow % oldTotalRows) + + val oldLine = oldLines[internalOldRow] + val cursorAtThisRow = externalOldRow == oldCursorRow + if (oldLine == null || (!(!newCursorPlaced && cursorAtThisRow)) && oldLine.isBlank()) { + skippedBlankLines++ + continue + } else if (skippedBlankLines > 0) { + for (i in 0 until skippedBlankLines) { + if (currentOutputExternalRow == screenRows - 1) { + scrollDownOneLine(0, screenRows, currentStyle) + } else { + currentOutputExternalRow++ + } + currentOutputExternalColumn = 0 + } + skippedBlankLines = 0 + } + + var lastNonSpaceIndex = 0 + var justToCursor = false + if (cursorAtThisRow || oldLine.lineWrap) { + lastNonSpaceIndex = oldLine.spaceUsed + if (cursorAtThisRow) justToCursor = true + } else { + for (i in 0 until oldLine.spaceUsed) + // NEWLY INTRODUCED BUG! Should not index oldLine.styles with char indices + if (oldLine.text[i] != ' '/* || oldLine.styles[i] != currentStyle */) + lastNonSpaceIndex = i + 1 + } + + var currentOldCol = 0 + var styleAtCol = 0L + var i = 0 + while (i < lastNonSpaceIndex) { + val c = oldLine.text[i] + val codePoint: Int + if (Character.isHighSurrogate(c)) { + i++ + codePoint = Character.toCodePoint(c, oldLine.text[i]) + } else { + codePoint = c.code + } + val displayWidth = WcWidth.width(codePoint) + if (displayWidth > 0) styleAtCol = oldLine.getStyle(currentOldCol) + + if (currentOutputExternalColumn + displayWidth > columns) { + setLineWrap(currentOutputExternalRow) + if (currentOutputExternalRow == screenRows - 1) { + if (newCursorPlaced) newCursorRow-- + scrollDownOneLine(0, screenRows, currentStyle) + } else { + currentOutputExternalRow++ + } + currentOutputExternalColumn = 0 + } + + val offsetDueToCombiningChar = if (displayWidth <= 0 && currentOutputExternalColumn > 0) 1 else 0 + val outputColumn = currentOutputExternalColumn - offsetDueToCombiningChar + setChar(outputColumn, currentOutputExternalRow, codePoint, styleAtCol) + + if (displayWidth > 0) { + if (oldCursorRow == externalOldRow && oldCursorColumn == currentOldCol) { + newCursorColumn = currentOutputExternalColumn + newCursorRow = currentOutputExternalRow + newCursorPlaced = true + } + currentOldCol += displayWidth + currentOutputExternalColumn += displayWidth + if (justToCursor && newCursorPlaced) break + } + i++ + } + if (externalOldRow != (oldScreenRows - 1) && !oldLine.lineWrap) { + if (currentOutputExternalRow == screenRows - 1) { + if (newCursorPlaced) newCursorRow-- + scrollDownOneLine(0, screenRows, currentStyle) + } else { + currentOutputExternalRow++ + } + currentOutputExternalColumn = 0 + } + } + + cursor[0] = newCursorColumn + cursor[1] = newCursorRow + } + + // Handle cursor scrolling off screen: + if (cursor[0] < 0 || cursor[1] < 0) { + cursor[0] = 0 + cursor[1] = 0 + } + } + + /** + * Block copy lines and associated metadata from one location to another in the circular buffer, taking wraparound + * into account. + * + * @param srcInternal The first line to be copied. + * @param len The number of lines to be copied. + */ + private fun blockCopyLinesDown(srcInternal: Int, len: Int) { + if (len == 0) return + + val start = len - 1 + val lineToBeOverWritten = lines[(srcInternal + start + 1) % totalRows] + for (i in start downTo 0) + lines[(srcInternal + i + 1) % totalRows] = lines[(srcInternal + i) % totalRows] + lines[srcInternal % totalRows] = lineToBeOverWritten + } + + /** + * Scroll the screen down one line. To scroll the whole screen of a 24 line screen, the arguments would be (0, 24). + * + * @param topMargin First line that is scrolled. + * @param bottomMargin One line after the last line that is scrolled. + * @param style the style for the newly exposed line. + */ + fun scrollDownOneLine(topMargin: Int, bottomMargin: Int, style: Long) { + if (topMargin > bottomMargin - 1 || topMargin < 0 || bottomMargin > screenRows) + throw IllegalArgumentException("topMargin=$topMargin, bottomMargin=$bottomMargin, screenRows=$screenRows") + + blockCopyLinesDown(screenFirstRow, topMargin) + blockCopyLinesDown(externalToInternalRow(bottomMargin), screenRows - bottomMargin) + + screenFirstRow = (screenFirstRow + 1) % totalRows + if (activeTranscriptRows < totalRows - screenRows) activeTranscriptRows++ + + val blankRow = externalToInternalRow(bottomMargin - 1) + if (lines[blankRow] == null) { + lines[blankRow] = TerminalRow(columns, style) + } else { + lines[blankRow]!!.clear(style) + } + } + + /** + * Block copy characters from one position in the screen to another. The two positions can overlap. All characters + * of the source and destination must be within the bounds of the screen, or else an InvalidParameterException will + * be thrown. + * + * @param sx source X coordinate + * @param sy source Y coordinate + * @param w width + * @param h height + * @param dx destination X coordinate + * @param dy destination Y coordinate + */ + fun blockCopy(sx: Int, sy: Int, w: Int, h: Int, dx: Int, dy: Int) { + if (w == 0) return + if (sx < 0 || sx + w > columns || sy < 0 || sy + h > screenRows || dx < 0 || dx + w > columns || dy < 0 || dy + h > screenRows) + throw IllegalArgumentException() + val copyingUp = sy > dy + for (y in 0 until h) { + val y2 = if (copyingUp) y else (h - (y + 1)) + val sourceRow = allocateFullLineIfNecessary(externalToInternalRow(sy + y2)) + allocateFullLineIfNecessary(externalToInternalRow(dy + y2)).copyInterval(sourceRow, sx, sx + w, dx) + } + } + + /** + * Block set characters. All characters must be within the bounds of the screen, or else an + * InvalidParameterException will be thrown. Typically this is called with a "val" argument of 32 to clear a block + * of characters. + */ + fun blockSet(sx: Int, sy: Int, w: Int, h: Int, `val`: Int, style: Long) { + if (sx < 0 || sx + w > columns || sy < 0 || sy + h > screenRows) { + throw IllegalArgumentException( + "Illegal arguments! blockSet($sx, $sy, $w, $h, $`val`, $columns, $screenRows)") + } + for (y in 0 until h) + for (x in 0 until w) + setChar(sx + x, sy + y, `val`, style) + } + + fun allocateFullLineIfNecessary(row: Int): TerminalRow { + return lines[row] ?: TerminalRow(columns, 0).also { lines[row] = it } + } + + fun setChar(column: Int, row: Int, codePoint: Int, style: Long) { + if (row < 0 || row >= screenRows || column < 0 || column >= columns) + throw IllegalArgumentException("TerminalBuffer.setChar(): row=$row, column=$column, screenRows=$screenRows, columns=$columns") + val internalRow = externalToInternalRow(row) + allocateFullLineIfNecessary(internalRow).setChar(column, codePoint, style) + } + + fun getStyleAt(externalRow: Int, column: Int): Long { + return allocateFullLineIfNecessary(externalToInternalRow(externalRow)).getStyle(column) + } + + /** Support for http://vt100.net/docs/vt510-rm/DECCARA and http://vt100.net/docs/vt510-rm/DECCARA */ + fun setOrClearEffect(bits: Int, setOrClear: Boolean, reverse: Boolean, rectangular: Boolean, leftMargin: Int, rightMargin: Int, top: Int, left: Int, + bottom: Int, right: Int) { + for (y in top until bottom) { + val line = lines[externalToInternalRow(y)]!! + val startOfLine = if (rectangular || y == top) left else leftMargin + val endOfLine = if (rectangular || y + 1 == bottom) right else rightMargin + for (x in startOfLine until endOfLine) { + val currentStyle = line.getStyle(x) + val foreColor = TextStyle.decodeForeColor(currentStyle) + val backColor = TextStyle.decodeBackColor(currentStyle) + var effect = TextStyle.decodeEffect(currentStyle) + if (reverse) { + effect = (effect and bits.inv()) or (bits and effect.inv()) + } else if (setOrClear) { + effect = effect or bits + } else { + effect = effect and bits.inv() + } + line.styles[x] = TextStyle.encode(foreColor, backColor, effect) + } + } + } + + fun clearTranscript() { + if (screenFirstRow < activeTranscriptRows) { + Arrays.fill(lines, totalRows + screenFirstRow - activeTranscriptRows, totalRows, null) + Arrays.fill(lines, 0, screenFirstRow, null) + } else { + Arrays.fill(lines, screenFirstRow - activeTranscriptRows, screenFirstRow, null) + } + activeTranscriptRows = 0 + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalEmulator.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalEmulator.kt new file mode 100644 index 000000000..4e7fab8b6 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalEmulator.kt @@ -0,0 +1,1588 @@ +package com.topjohnwu.magisk.terminal + +import android.util.Base64 +import timber.log.Timber +import java.util.Stack + +/** + * Renders text into a screen. Contains all the terminal-specific knowledge and state. Emulates a subset of the X Window + * System xterm terminal, which in turn is an emulator for a subset of the Digital Equipment Corporation vt100 terminal. + * + * References: + * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html + * - http://en.wikipedia.org/wiki/ANSI_escape_code + * - http://man.he.net/man4/console_codes + * - http://bazaar.launchpad.net/~leonerd/libvterm/trunk/view/head:/src/state.c + * - http://www.columbia.edu/~kermit/k95manual/iso2022.html + * - http://www.vt100.net/docs/vt510-rm/chapter4 + * - http://en.wikipedia.org/wiki/ISO/IEC_2022 - for 7-bit and 8-bit GL GR explanation + * - http://bjh21.me.uk/all-escapes/all-escapes.txt - extensive! + * - http://woldlab.caltech.edu/~diane/kde4.10/workingdir/kubuntu/konsole/doc/developer/old-documents/VT100/techref.html + */ +class TerminalEmulator( + columns: Int, + rows: Int, + cellWidthPixels: Int, + cellHeightPixels: Int, + transcriptRows: Int?, +) { + + companion object { + private const val LOG_ESCAPE_SEQUENCES = false + + /** Used for invalid data - http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */ + const val UNICODE_REPLACEMENT_CHAR = 0xFFFD + + private const val ESC_NONE = 0 + private const val ESC = 1 + private const val ESC_POUND = 2 + private const val ESC_SELECT_LEFT_PAREN = 3 + private const val ESC_SELECT_RIGHT_PAREN = 4 + private const val ESC_CSI = 6 + private const val ESC_CSI_QUESTIONMARK = 7 + private const val ESC_CSI_DOLLAR = 8 + private const val ESC_PERCENT = 9 + private const val ESC_OSC = 10 + private const val ESC_OSC_ESC = 11 + private const val ESC_CSI_BIGGERTHAN = 12 + private const val ESC_P = 13 + private const val ESC_CSI_QUESTIONMARK_ARG_DOLLAR = 14 + private const val ESC_CSI_ARGS_SPACE = 15 + private const val ESC_CSI_ARGS_ASTERIX = 16 + private const val ESC_CSI_DOUBLE_QUOTE = 17 + private const val ESC_CSI_SINGLE_QUOTE = 18 + private const val ESC_CSI_EXCLAMATION = 19 + private const val ESC_APC = 20 + private const val ESC_APC_ESCAPE = 21 + private const val ESC_CSI_UNSUPPORTED_PARAMETER_BYTE = 22 + private const val ESC_CSI_UNSUPPORTED_INTERMEDIATE_BYTE = 23 + + private const val MAX_ESCAPE_PARAMETERS = 32 + private const val MAX_OSC_STRING_LENGTH = 8192 + + private const val DECSET_BIT_APPLICATION_CURSOR_KEYS = 1 + private const val DECSET_BIT_REVERSE_VIDEO = 1 shl 1 + private const val DECSET_BIT_ORIGIN_MODE = 1 shl 2 + private const val DECSET_BIT_AUTOWRAP = 1 shl 3 + private const val DECSET_BIT_CURSOR_ENABLED = 1 shl 4 + private const val DECSET_BIT_APPLICATION_KEYPAD = 1 shl 5 + private const val DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE = 1 shl 6 + private const val DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT = 1 shl 7 + private const val DECSET_BIT_SEND_FOCUS_EVENTS = 1 shl 8 + private const val DECSET_BIT_MOUSE_PROTOCOL_SGR = 1 shl 9 + private const val DECSET_BIT_BRACKETED_PASTE_MODE = 1 shl 10 + private const val DECSET_BIT_LEFTRIGHT_MARGIN_MODE = 1 shl 11 + private const val DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE = 1 shl 12 + + const val TERMINAL_TRANSCRIPT_ROWS_MIN = 100 + const val TERMINAL_TRANSCRIPT_ROWS_MAX = 50000 + const val DEFAULT_TERMINAL_TRANSCRIPT_ROWS = 2000 + + const val TERMINAL_CURSOR_STYLE_BLOCK = 0 + const val TERMINAL_CURSOR_STYLE_UNDERLINE = 1 + const val TERMINAL_CURSOR_STYLE_BAR = 2 + const val DEFAULT_TERMINAL_CURSOR_STYLE = TERMINAL_CURSOR_STYLE_BLOCK + + val TERMINAL_CURSOR_STYLES_LIST = intArrayOf( + TERMINAL_CURSOR_STYLE_BLOCK, + TERMINAL_CURSOR_STYLE_UNDERLINE, + TERMINAL_CURSOR_STYLE_BAR + ) + + private const val LOG_TAG = "TerminalEmulator" + + fun mapDecSetBitToInternalBit(decsetBit: Int): Int = when (decsetBit) { + 1 -> DECSET_BIT_APPLICATION_CURSOR_KEYS + 5 -> DECSET_BIT_REVERSE_VIDEO + 6 -> DECSET_BIT_ORIGIN_MODE + 7 -> DECSET_BIT_AUTOWRAP + 25 -> DECSET_BIT_CURSOR_ENABLED + 66 -> DECSET_BIT_APPLICATION_KEYPAD + 69 -> DECSET_BIT_LEFTRIGHT_MARGIN_MODE + 1000 -> DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE + 1002 -> DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT + 1004 -> DECSET_BIT_SEND_FOCUS_EVENTS + 1006 -> DECSET_BIT_MOUSE_PROTOCOL_SGR + 2004 -> DECSET_BIT_BRACKETED_PASTE_MODE + else -> -1 + } + } + + var title: String? = null + private set + private val titleStack = Stack() + + var cursorRow = 0 + private set + var cursorCol = 0 + private set + + var mRows: Int = rows + var mColumns: Int = columns + + private var mCellWidthPixels: Int = cellWidthPixels + private var mCellHeightPixels: Int = cellHeightPixels + + var cursorStyle = DEFAULT_TERMINAL_CURSOR_STYLE + private set + + private val mMainBuffer: TerminalBuffer + internal val mAltBuffer: TerminalBuffer + var screen: TerminalBuffer + private set + + var onCopyToClipboard: ((String) -> Unit)? = null + var onScreenUpdate: (() -> Unit)? = null + + private var mArgIndex = 0 + private val mArgs = IntArray(MAX_ESCAPE_PARAMETERS) + private var mArgsSubParamsBitSet = 0 + + private val mOSCOrDeviceControlArgs = StringBuilder() + + private var mContinueSequence = false + private var mEscapeState = ESC_NONE + + private val mSavedStateMain = SavedScreenState() + private val mSavedStateAlt = SavedScreenState() + + private var mUseLineDrawingG0 = false + private var mUseLineDrawingG1 = false + private var mUseLineDrawingUsesG0 = true + + private var mCurrentDecSetFlags = 0 + private var mSavedDecSetFlags = 0 + + private var mInsertMode = false + private var mTabStop: BooleanArray + + private var mTopMargin = 0 + private var mBottomMargin = 0 + private var mLeftMargin = 0 + private var mRightMargin = 0 + + private var mAboutToAutoWrap = false + private var mCursorBlinkingEnabled = false + private var mCursorBlinkState = false + + private var mForeColor = 0 + private var mBackColor = 0 + private var mUnderlineColor = 0 + private var mEffect = 0 + + var scrollCounter = 0 + private set + var isAutoScrollDisabled = false + private set + + private var mUtf8ToFollow = 0 + private var mUtf8Index = 0 + private val mUtf8InputBuffer = ByteArray(4) + private var mLastEmittedCodePoint = -1 + + val mColors = TerminalColors() + + init { + mMainBuffer = TerminalBuffer(columns, getTerminalTranscriptRows(transcriptRows), rows) + mAltBuffer = TerminalBuffer(columns, rows, rows) + screen = mMainBuffer + mTabStop = BooleanArray(mColumns) + reset() + } + + val isAlternateBufferActive: Boolean get() = screen === mAltBuffer + + private fun getTerminalTranscriptRows(transcriptRows: Int?): Int { + return if (transcriptRows == null || transcriptRows < TERMINAL_TRANSCRIPT_ROWS_MIN || transcriptRows > TERMINAL_TRANSCRIPT_ROWS_MAX) + DEFAULT_TERMINAL_TRANSCRIPT_ROWS + else + transcriptRows + } + + fun resize(columns: Int, rows: Int, cellWidthPixels: Int, cellHeightPixels: Int) { + this.mCellWidthPixels = cellWidthPixels + this.mCellHeightPixels = cellHeightPixels + + if (mRows == rows && mColumns == columns) { + return + } else if (columns < 2 || rows < 2) { + throw IllegalArgumentException("rows=$rows, columns=$columns") + } + + if (mRows != rows) { + mRows = rows + mTopMargin = 0 + mBottomMargin = mRows + } + if (mColumns != columns) { + val oldColumns = mColumns + mColumns = columns + val oldTabStop = mTabStop + mTabStop = BooleanArray(mColumns) + setDefaultTabStops() + val toTransfer = minOf(oldColumns, columns) + System.arraycopy(oldTabStop, 0, mTabStop, 0, toTransfer) + mLeftMargin = 0 + mRightMargin = mColumns + } + + resizeScreen() + } + + private fun resizeScreen() { + val cursor = intArrayOf(cursorCol, cursorRow) + val newTotalRows = if (screen === mAltBuffer) mRows else mMainBuffer.totalRows + screen.resize(mColumns, mRows, newTotalRows, cursor, style, isAlternateBufferActive) + cursorCol = cursor[0] + cursorRow = cursor[1] + } + + + fun setCursorStyle() { + cursorStyle = DEFAULT_TERMINAL_CURSOR_STYLE + } + + val isReverseVideo: Boolean get() = isDecsetInternalBitSet(DECSET_BIT_REVERSE_VIDEO) + + val isCursorEnabled: Boolean get() = isDecsetInternalBitSet(DECSET_BIT_CURSOR_ENABLED) + + fun shouldCursorBeVisible(): Boolean { + if (!isCursorEnabled) return false + return if (mCursorBlinkingEnabled) mCursorBlinkState else true + } + + fun setCursorBlinkingEnabled(cursorBlinkingEnabled: Boolean) { + this.mCursorBlinkingEnabled = cursorBlinkingEnabled + } + + fun setCursorBlinkState(cursorBlinkState: Boolean) { + this.mCursorBlinkState = cursorBlinkState + } + + fun isKeypadApplicationMode(): Boolean = isDecsetInternalBitSet(DECSET_BIT_APPLICATION_KEYPAD) + + private fun isDecsetInternalBitSet(bit: Int): Boolean = (mCurrentDecSetFlags and bit) != 0 + + private fun setDecsetinternalBit(internalBit: Int, set: Boolean) { + if (set) { + if (internalBit == DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE) { + setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT, false) + } else if (internalBit == DECSET_BIT_MOUSE_TRACKING_BUTTON_EVENT) { + setDecsetinternalBit(DECSET_BIT_MOUSE_TRACKING_PRESS_RELEASE, false) + } + } + if (set) { + mCurrentDecSetFlags = mCurrentDecSetFlags or internalBit + } else { + mCurrentDecSetFlags = mCurrentDecSetFlags and internalBit.inv() + } + } + + private fun setDefaultTabStops() { + for (i in 0 until mColumns) + mTabStop[i] = (i and 7) == 0 && i != 0 + } + + fun append(buffer: ByteArray, length: Int) { + for (i in 0 until length) + processByte(buffer[i]) + } + + private fun processByte(byteToProcess: Byte) { + if (mUtf8ToFollow > 0) { + if ((byteToProcess.toInt() and 0b11000000) == 0b10000000) { + mUtf8InputBuffer[mUtf8Index] = byteToProcess + mUtf8Index++ + if (--mUtf8ToFollow == 0) { + val firstByteMask = when (mUtf8Index) { + 2 -> 0b00011111 + 3 -> 0b00001111 + else -> 0b00000111 + } + var codePoint = mUtf8InputBuffer[0].toInt() and firstByteMask + for (i in 1 until mUtf8Index) + codePoint = (codePoint shl 6) or (mUtf8InputBuffer[i].toInt() and 0b00111111) + if (((codePoint <= 0b1111111) && mUtf8Index > 1) || (codePoint < 0b11111111111 && mUtf8Index > 2) + || (codePoint < 0b1111111111111111 && mUtf8Index > 3) + ) { + codePoint = UNICODE_REPLACEMENT_CHAR + } + + mUtf8Index = 0 + mUtf8ToFollow = 0 + + if (codePoint in 0x80..0x9F) { + // C1 control character, ignore + } else { + when (Character.getType(codePoint).toByte()) { + Character.UNASSIGNED, Character.SURROGATE -> + codePoint = UNICODE_REPLACEMENT_CHAR + } + processCodePoint(codePoint) + } + } + } else { + mUtf8Index = 0 + mUtf8ToFollow = 0 + emitCodePoint(UNICODE_REPLACEMENT_CHAR) + processByte(byteToProcess) + } + } else { + if ((byteToProcess.toInt() and 0b10000000) == 0) { + processCodePoint(byteToProcess.toInt()) + return + } else if ((byteToProcess.toInt() and 0b11100000) == 0b11000000) { + mUtf8ToFollow = 1 + } else if ((byteToProcess.toInt() and 0b11110000) == 0b11100000) { + mUtf8ToFollow = 2 + } else if ((byteToProcess.toInt() and 0b11111000) == 0b11110000) { + mUtf8ToFollow = 3 + } else { + processCodePoint(UNICODE_REPLACEMENT_CHAR) + return + } + mUtf8InputBuffer[mUtf8Index] = byteToProcess + mUtf8Index++ + } + } + + fun processCodePoint(b: Int) { + if (mEscapeState == ESC_APC) { + doApc(b) + return + } else if (mEscapeState == ESC_APC_ESCAPE) { + doApcEscape(b) + return + } + + when (b) { + 0 -> { /* NUL, do nothing */ } + 7 -> { + if (mEscapeState == ESC_OSC) doOsc(b) + } + 8 -> { + if (mLeftMargin == cursorCol) { + val previousRow = cursorRow - 1 + if (previousRow >= 0 && screen.getLineWrap(previousRow)) { + screen.clearLineWrap(previousRow) + setCursorRowCol(previousRow, mRightMargin - 1) + } + } else { + setCursorCol(cursorCol - 1) + } + } + 9 -> cursorCol = nextTabStop(1) + 10, 11, 12 -> doLinefeed() + 13 -> setCursorCol(mLeftMargin) + 14 -> mUseLineDrawingUsesG0 = false + 15 -> mUseLineDrawingUsesG0 = true + 24, 26 -> { + if (mEscapeState != ESC_NONE) { + mEscapeState = ESC_NONE + emitCodePoint(127) + } + } + 27 -> { + if (mEscapeState == ESC_P) { + return + } else if (mEscapeState != ESC_OSC) { + startEscapeSequence() + } else { + doOsc(b) + } + } + else -> { + mContinueSequence = false + when (mEscapeState) { + ESC_NONE -> if (b >= 32) emitCodePoint(b) + ESC -> doEsc(b) + ESC_POUND -> doEscPound(b) + ESC_SELECT_LEFT_PAREN -> mUseLineDrawingG0 = (b == '0'.code) + ESC_SELECT_RIGHT_PAREN -> mUseLineDrawingG1 = (b == '0'.code) + ESC_CSI -> doCsi(b) + ESC_CSI_UNSUPPORTED_PARAMETER_BYTE, ESC_CSI_UNSUPPORTED_INTERMEDIATE_BYTE -> + doCsiUnsupportedParameterOrIntermediateByte(b) + ESC_CSI_EXCLAMATION -> { + if (b == 'p'.code) reset() else unknownSequence(b) + } + ESC_CSI_QUESTIONMARK -> doCsiQuestionMark(b) + ESC_CSI_BIGGERTHAN -> doCsiBiggerThan(b) + ESC_CSI_DOLLAR -> { + val originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE) + val effectiveTopMargin = if (originMode) mTopMargin else 0 + val effectiveBottomMargin = if (originMode) mBottomMargin else mRows + val effectiveLeftMargin = if (originMode) mLeftMargin else 0 + val effectiveRightMargin = if (originMode) mRightMargin else mColumns + when (b) { + 'v'.code -> { + val topSource = minOf(getArg(0, 1, true) - 1 + effectiveTopMargin, mRows) + val leftSource = minOf(getArg(1, 1, true) - 1 + effectiveLeftMargin, mColumns) + val bottomSource = minOf(maxOf(getArg(2, mRows, true) + effectiveTopMargin, topSource), mRows) + val rightSource = minOf(maxOf(getArg(3, mColumns, true) + effectiveLeftMargin, leftSource), mColumns) + val destionationTop = minOf(getArg(5, 1, true) - 1 + effectiveTopMargin, mRows) + val destinationLeft = minOf(getArg(6, 1, true) - 1 + effectiveLeftMargin, mColumns) + val heightToCopy = minOf(mRows - destionationTop, bottomSource - topSource) + val widthToCopy = minOf(mColumns - destinationLeft, rightSource - leftSource) + screen.blockCopy(leftSource, topSource, widthToCopy, heightToCopy, destinationLeft, destionationTop) + } + '{'.code, 'x'.code, 'z'.code -> { + val erase = b != 'x'.code + val selective = b == '{'.code + val keepVisualAttributes = erase && selective + var argIndex = 0 + val fillChar = if (erase) ' '.code else getArg(argIndex++, -1, true) + if ((fillChar in 32..126) || (fillChar in 160..255)) { + val top = minOf(getArg(argIndex++, 1, true) + effectiveTopMargin, effectiveBottomMargin + 1) + val left = minOf(getArg(argIndex++, 1, true) + effectiveLeftMargin, effectiveRightMargin + 1) + val bottom = minOf(getArg(argIndex++, mRows, true) + effectiveTopMargin, effectiveBottomMargin) + val right = minOf(getArg(argIndex, mColumns, true) + effectiveLeftMargin, effectiveRightMargin) + val style = style + for (row in top - 1 until bottom) + for (col in left - 1 until right) + if (!selective || (TextStyle.decodeEffect(screen.getStyleAt(row, col)) and TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0) + screen.setChar(col, row, fillChar, if (keepVisualAttributes) screen.getStyleAt(row, col) else style) + } + } + 'r'.code, 't'.code -> { + val reverse = b == 't'.code + val top = minOf(getArg(0, 1, true) - 1, effectiveBottomMargin) + effectiveTopMargin + val left = minOf(getArg(1, 1, true) - 1, effectiveRightMargin) + effectiveLeftMargin + val bottom = minOf(getArg(2, mRows, true) + 1, effectiveBottomMargin - 1) + effectiveTopMargin + val right = minOf(getArg(3, mColumns, true) + 1, effectiveRightMargin - 1) + effectiveLeftMargin + if (mArgIndex >= 4) { + if (mArgIndex >= mArgs.size) mArgIndex = mArgs.size - 1 + for (i in 4..mArgIndex) { + var bits = 0 + var setOrClear = true + when (getArg(i, 0, false)) { + 0 -> { + bits = (TextStyle.CHARACTER_ATTRIBUTE_BOLD or TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE or TextStyle.CHARACTER_ATTRIBUTE_BLINK + or TextStyle.CHARACTER_ATTRIBUTE_INVERSE) + if (!reverse) setOrClear = false + } + 1 -> bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD + 4 -> bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE + 5 -> bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK + 7 -> bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE + 22 -> { + bits = TextStyle.CHARACTER_ATTRIBUTE_BOLD + setOrClear = false + } + 24 -> { + bits = TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE + setOrClear = false + } + 25 -> { + bits = TextStyle.CHARACTER_ATTRIBUTE_BLINK + setOrClear = false + } + 27 -> { + bits = TextStyle.CHARACTER_ATTRIBUTE_INVERSE + setOrClear = false + } + } + if (reverse && !setOrClear) { + // Reverse attributes in rectangular area ignores non-(1,4,5,7) bits. + } else { + screen.setOrClearEffect( + bits, setOrClear, reverse, isDecsetInternalBitSet(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE), + effectiveLeftMargin, effectiveRightMargin, top, left, bottom, right + ) + } + } + } + } + else -> unknownSequence(b) + } + } + ESC_CSI_DOUBLE_QUOTE -> { + if (b == 'q'.code) { + val arg = getArg0(0) + if (arg == 0 || arg == 2) { + mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_PROTECTED.inv() + } else if (arg == 1) { + mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_PROTECTED + } else { + unknownSequence(b) + } + } else { + unknownSequence(b) + } + } + ESC_CSI_SINGLE_QUOTE -> { + when (b) { + '}'.code -> { + val columnsAfterCursor = mRightMargin - cursorCol + val columnsToInsert = minOf(getArg0(1), columnsAfterCursor) + val columnsToMove = columnsAfterCursor - columnsToInsert + screen.blockCopy(cursorCol, 0, columnsToMove, mRows, cursorCol + columnsToInsert, 0) + blockClear(cursorCol, 0, columnsToInsert, mRows) + } + '~'.code -> { + val columnsAfterCursor = mRightMargin - cursorCol + val columnsToDelete = minOf(getArg0(1), columnsAfterCursor) + val columnsToMove = columnsAfterCursor - columnsToDelete + screen.blockCopy(cursorCol + columnsToDelete, 0, columnsToMove, mRows, cursorCol, 0) + } + else -> unknownSequence(b) + } + } + ESC_PERCENT -> { /* ignore */ } + ESC_OSC -> doOsc(b) + ESC_OSC_ESC -> doOscEsc(b) + ESC_P -> doDeviceControl(b) + ESC_CSI_QUESTIONMARK_ARG_DOLLAR -> { + if (b != 'p'.code) unknownSequence(b) + } + ESC_CSI_ARGS_SPACE -> { + val arg = getArg0(0) + when (b) { + 'q'.code -> when (arg) { + 0, 1, 2 -> cursorStyle = TERMINAL_CURSOR_STYLE_BLOCK + 3, 4 -> cursorStyle = TERMINAL_CURSOR_STYLE_UNDERLINE + 5, 6 -> cursorStyle = TERMINAL_CURSOR_STYLE_BAR + } + 't'.code, 'u'.code -> { /* Set margin-bell volume - ignore */ } + else -> unknownSequence(b) + } + } + ESC_CSI_ARGS_ASTERIX -> { + val attributeChangeExtent = getArg0(0) + if (b == 'x'.code && attributeChangeExtent in 0..2) { + setDecsetinternalBit(DECSET_BIT_RECTANGULAR_CHANGEATTRIBUTE, attributeChangeExtent == 2) + } else { + unknownSequence(b) + } + } + else -> unknownSequence(b) + } + if (!mContinueSequence) mEscapeState = ESC_NONE + } + } + } + + private fun doDeviceControl(b: Int) { + when (b) { + '\\'.code -> { + val dcs = mOSCOrDeviceControlArgs.toString() + if (!dcs.startsWith("\$q") && !dcs.startsWith("+q")) { + if (LOG_ESCAPE_SEQUENCES) + Timber.tag(LOG_TAG).e("Unrecognized device control string: $dcs") + } + finishSequence() + } + else -> { + if (mOSCOrDeviceControlArgs.length > MAX_OSC_STRING_LENGTH) { + mOSCOrDeviceControlArgs.clear() + finishSequence() + } else { + mOSCOrDeviceControlArgs.appendCodePoint(b) + continueSequence(mEscapeState) + } + } + } + } + + private fun doApc(b: Int) { + if (b == 27) { + continueSequence(ESC_APC_ESCAPE) + } + } + + private fun doApcEscape(b: Int) { + if (b == '\\'.code) { + finishSequence() + } else { + continueSequence(ESC_APC) + } + } + + private fun nextTabStop(numTabs: Int): Int { + var remaining = numTabs + for (i in cursorCol + 1 until mColumns) + if (mTabStop[i] && --remaining == 0) return minOf(i, mRightMargin) + return mRightMargin - 1 + } + + private fun doCsiUnsupportedParameterOrIntermediateByte(b: Int) { + if (mEscapeState == ESC_CSI_UNSUPPORTED_PARAMETER_BYTE && b in 0x30..0x3F) { + continueSequence(ESC_CSI_UNSUPPORTED_PARAMETER_BYTE) + } else if (b in 0x20..0x2F) { + continueSequence(ESC_CSI_UNSUPPORTED_INTERMEDIATE_BYTE) + } else if (b in 0x40..0x7E) { + finishSequence() + } else { + unknownSequence(b) + } + } + + private fun doCsiQuestionMark(b: Int) { + when (b) { + 'J'.code, 'K'.code -> { + mAboutToAutoWrap = false + val fillChar = ' '.code + var startCol = -1 + var startRow = -1 + var endCol = -1 + var endRow = -1 + val justRow = (b == 'K'.code) + when (getArg0(0)) { + 0 -> { + startCol = cursorCol; startRow = cursorRow + endCol = mColumns; endRow = if (justRow) cursorRow + 1 else mRows + } + 1 -> { + startCol = 0; startRow = if (justRow) cursorRow else 0 + endCol = cursorCol + 1; endRow = cursorRow + 1 + } + 2 -> { + startCol = 0; startRow = if (justRow) cursorRow else 0 + endCol = mColumns; endRow = if (justRow) cursorRow + 1 else mRows + } + else -> unknownSequence(b) + } + val style = style + for (row in startRow until endRow) { + for (col in startCol until endCol) { + if ((TextStyle.decodeEffect(screen.getStyleAt(row, col)) and TextStyle.CHARACTER_ATTRIBUTE_PROTECTED) == 0) + screen.setChar(col, row, fillChar, style) + } + } + } + 'h'.code, 'l'.code -> { + if (mArgIndex >= mArgs.size) mArgIndex = mArgs.size - 1 + for (i in 0..mArgIndex) + doDecSetOrReset(b == 'h'.code, mArgs[i]) + } + 'n'.code -> { + finishSequence() + return + } + 'r'.code, 's'.code -> { + if (mArgIndex >= mArgs.size) mArgIndex = mArgs.size - 1 + for (i in 0..mArgIndex) { + val externalBit = mArgs[i] + val internalBit = mapDecSetBitToInternalBit(externalBit) + if (internalBit == -1) { + Timber.tag(LOG_TAG).w("Ignoring request to save/recall decset bit=$externalBit") + } else { + if (b == 's'.code) { + mSavedDecSetFlags = mSavedDecSetFlags or internalBit + } else { + doDecSetOrReset((mSavedDecSetFlags and internalBit) != 0, externalBit) + } + } + } + } + '$'.code -> { + continueSequence(ESC_CSI_QUESTIONMARK_ARG_DOLLAR) + return + } + else -> parseArg(b) + } + } + + fun doDecSetOrReset(setting: Boolean, externalBit: Int) { + val internalBit = mapDecSetBitToInternalBit(externalBit) + if (internalBit != -1) { + setDecsetinternalBit(internalBit, setting) + } + when (externalBit) { + 1 -> { /* Application Cursor Keys (DECCKM) */ } + 3 -> { + mLeftMargin = 0 + mTopMargin = 0 + mBottomMargin = mRows + mRightMargin = mColumns + setDecsetinternalBit(DECSET_BIT_LEFTRIGHT_MARGIN_MODE, false) + blockClear(0, 0, mColumns, mRows) + setCursorRowCol(0, 0) + } + 4 -> { /* DECSCLM-Scrolling Mode. Ignore */ } + 5 -> { /* Reverse video. No action */ } + 6 -> if (setting) setCursorPosition(0, 0) + 7, 8, 9, 12, 25 -> { /* Cursor state change - ignored for read-only */ } + 40, 45, 66 -> { /* Ignore */ } + 69 -> { + if (!setting) { + mLeftMargin = 0 + mRightMargin = mColumns + } + } + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1015, 1034 -> { /* Ignore */ } + 1048 -> if (setting) saveCursor() else restoreCursor() + 47, 1047, 1049 -> { + val newScreen = if (setting) mAltBuffer else mMainBuffer + if (newScreen !== screen) { + val resized = !(newScreen.columns == mColumns && newScreen.screenRows == mRows) + if (setting) saveCursor() + screen = newScreen + if (!setting) { + val col = mSavedStateMain.mSavedCursorCol + val row = mSavedStateMain.mSavedCursorRow + restoreCursor() + if (resized) { + cursorCol = col + cursorRow = row + } + } + if (resized) resizeScreen() + if (newScreen === mAltBuffer) + newScreen.blockSet(0, 0, mColumns, mRows, ' '.code, style) + } + } + 2004 -> { /* Bracketed paste mode - setting bit is enough */ } + else -> unknownParameter(externalBit) + } + } + + private fun doCsiBiggerThan(b: Int) { + when (b) { + 'c'.code -> { /* Secondary device attributes - ignored for read-only */ } + 'm'.code -> Timber.tag(LOG_TAG).e("(ignored) CSI > MODIFY RESOURCE: ${getArg0(-1)} to ${getArg1(-1)}") + else -> parseArg(b) + } + } + + private fun startEscapeSequence() { + mEscapeState = ESC + mArgIndex = 0 + mArgs.fill(-1) + mArgsSubParamsBitSet = 0 + } + + private fun doLinefeed() { + val belowScrollingRegion = cursorRow >= mBottomMargin + var newCursorRow = cursorRow + 1 + if (belowScrollingRegion) { + if (cursorRow != mRows - 1) { + setCursorRow(newCursorRow) + } + } else { + if (newCursorRow == mBottomMargin) { + scrollDownOneLine() + newCursorRow = mBottomMargin - 1 + } + setCursorRow(newCursorRow) + } + } + + private fun continueSequence(state: Int) { + mEscapeState = state + mContinueSequence = true + } + + private fun doEscPound(b: Int) { + when (b) { + '8'.code -> screen.blockSet(0, 0, mColumns, mRows, 'E'.code, style) + else -> unknownSequence(b) + } + } + + private fun doEsc(b: Int) { + when (b) { + '#'.code -> continueSequence(ESC_POUND) + '('.code -> continueSequence(ESC_SELECT_LEFT_PAREN) + ')'.code -> continueSequence(ESC_SELECT_RIGHT_PAREN) + '6'.code -> { + if (cursorCol > mLeftMargin) { + cursorCol-- + } else { + val rows = mBottomMargin - mTopMargin + screen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin + 1, mTopMargin) + screen.blockSet(mLeftMargin, mTopMargin, 1, rows, ' '.code, TextStyle.encode(mForeColor, mBackColor, 0)) + } + } + '7'.code -> saveCursor() + '8'.code -> restoreCursor() + '9'.code -> { + if (cursorCol < mRightMargin - 1) { + cursorCol++ + } else { + val rows = mBottomMargin - mTopMargin + screen.blockCopy(mLeftMargin + 1, mTopMargin, mRightMargin - mLeftMargin - 1, rows, mLeftMargin, mTopMargin) + screen.blockSet(mRightMargin - 1, mTopMargin, 1, rows, ' '.code, TextStyle.encode(mForeColor, mBackColor, 0)) + } + } + 'c'.code -> { + reset() + mMainBuffer.clearTranscript() + blockClear(0, 0, mColumns, mRows) + setCursorPosition(0, 0) + } + 'D'.code -> doLinefeed() + 'E'.code -> { + setCursorCol(if (isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE)) mLeftMargin else 0) + doLinefeed() + } + 'F'.code -> setCursorRowCol(0, mBottomMargin - 1) + 'H'.code -> mTabStop[cursorCol] = true + 'M'.code -> { + if (cursorRow <= mTopMargin) { + screen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin, mBottomMargin - (mTopMargin + 1), mLeftMargin, mTopMargin + 1) + blockClear(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin) + } else { + cursorRow-- + } + } + 'N'.code, '0'.code -> { /* SS2/SS3, ignore */ } + 'P'.code -> { + mOSCOrDeviceControlArgs.clear() + continueSequence(ESC_P) + } + '['.code -> continueSequence(ESC_CSI) + '='.code -> setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, true) + ']'.code -> { + mOSCOrDeviceControlArgs.clear() + continueSequence(ESC_OSC) + } + '>'.code -> setDecsetinternalBit(DECSET_BIT_APPLICATION_KEYPAD, false) + '_'.code -> continueSequence(ESC_APC) + '%'.code -> continueSequence(ESC_PERCENT) + else -> unknownSequence(b) + } + } + + private fun saveCursor() { + val state = if (screen === mMainBuffer) mSavedStateMain else mSavedStateAlt + state.mSavedCursorRow = cursorRow + state.mSavedCursorCol = cursorCol + state.mSavedEffect = mEffect + state.mSavedForeColor = mForeColor + state.mSavedBackColor = mBackColor + state.mSavedDecFlags = mCurrentDecSetFlags + state.mUseLineDrawingG0 = mUseLineDrawingG0 + state.mUseLineDrawingG1 = mUseLineDrawingG1 + state.mUseLineDrawingUsesG0 = mUseLineDrawingUsesG0 + } + + private fun restoreCursor() { + val state = if (screen === mMainBuffer) mSavedStateMain else mSavedStateAlt + setCursorRowCol(state.mSavedCursorRow, state.mSavedCursorCol) + mEffect = state.mSavedEffect + mForeColor = state.mSavedForeColor + mBackColor = state.mSavedBackColor + val mask = DECSET_BIT_AUTOWRAP or DECSET_BIT_ORIGIN_MODE + mCurrentDecSetFlags = (mCurrentDecSetFlags and mask.inv()) or (state.mSavedDecFlags and mask) + mUseLineDrawingG0 = state.mUseLineDrawingG0 + mUseLineDrawingG1 = state.mUseLineDrawingG1 + mUseLineDrawingUsesG0 = state.mUseLineDrawingUsesG0 + } + + private fun doCsi(b: Int) { + when (b) { + '!'.code -> continueSequence(ESC_CSI_EXCLAMATION) + '"'.code -> continueSequence(ESC_CSI_DOUBLE_QUOTE) + '\''.code -> continueSequence(ESC_CSI_SINGLE_QUOTE) + '$'.code -> continueSequence(ESC_CSI_DOLLAR) + '*'.code -> continueSequence(ESC_CSI_ARGS_ASTERIX) + '@'.code -> { + mAboutToAutoWrap = false + val columnsAfterCursor = mColumns - cursorCol + val spacesToInsert = minOf(getArg0(1), columnsAfterCursor) + val charsToMove = columnsAfterCursor - spacesToInsert + screen.blockCopy(cursorCol, cursorRow, charsToMove, 1, cursorCol + spacesToInsert, cursorRow) + blockClear(cursorCol, cursorRow, spacesToInsert) + } + 'A'.code -> setCursorRow(maxOf(0, cursorRow - getArg0(1))) + 'B'.code -> setCursorRow(minOf(mRows - 1, cursorRow + getArg0(1))) + 'C'.code, 'a'.code -> setCursorCol(minOf(mRightMargin - 1, cursorCol + getArg0(1))) + 'D'.code -> setCursorCol(maxOf(mLeftMargin, cursorCol - getArg0(1))) + 'E'.code -> setCursorPosition(0, cursorRow + getArg0(1)) + 'F'.code -> setCursorPosition(0, cursorRow - getArg0(1)) + 'G'.code -> setCursorCol(minOf(maxOf(1, getArg0(1)), mColumns) - 1) + 'H'.code, 'f'.code -> setCursorPosition(getArg1(1) - 1, getArg0(1) - 1) + 'I'.code -> setCursorCol(nextTabStop(getArg0(1))) + 'J'.code -> { + when (getArg0(0)) { + 0 -> { + blockClear(cursorCol, cursorRow, mColumns - cursorCol) + blockClear(0, cursorRow + 1, mColumns, mRows - (cursorRow + 1)) + } + 1 -> { + blockClear(0, 0, mColumns, cursorRow) + blockClear(0, cursorRow, cursorCol + 1) + } + 2 -> blockClear(0, 0, mColumns, mRows) + 3 -> mMainBuffer.clearTranscript() + else -> { + unknownSequence(b) + return + } + } + mAboutToAutoWrap = false + } + 'K'.code -> { + when (getArg0(0)) { + 0 -> blockClear(cursorCol, cursorRow, mColumns - cursorCol) + 1 -> blockClear(0, cursorRow, cursorCol + 1) + 2 -> blockClear(0, cursorRow, mColumns) + else -> { + unknownSequence(b) + return + } + } + mAboutToAutoWrap = false + } + 'L'.code -> { + val linesAfterCursor = mBottomMargin - cursorRow + val linesToInsert = minOf(getArg0(1), linesAfterCursor) + val linesToMove = linesAfterCursor - linesToInsert + screen.blockCopy(0, cursorRow, mColumns, linesToMove, 0, cursorRow + linesToInsert) + blockClear(0, cursorRow, mColumns, linesToInsert) + } + 'M'.code -> { + mAboutToAutoWrap = false + val linesAfterCursor = mBottomMargin - cursorRow + val linesToDelete = minOf(getArg0(1), linesAfterCursor) + val linesToMove = linesAfterCursor - linesToDelete + screen.blockCopy(0, cursorRow + linesToDelete, mColumns, linesToMove, 0, cursorRow) + blockClear(0, cursorRow + linesToMove, mColumns, linesToDelete) + } + 'P'.code -> { + mAboutToAutoWrap = false + val cellsAfterCursor = mColumns - cursorCol + val cellsToDelete = minOf(getArg0(1), cellsAfterCursor) + val cellsToMove = cellsAfterCursor - cellsToDelete + screen.blockCopy(cursorCol + cellsToDelete, cursorRow, cellsToMove, 1, cursorCol, cursorRow) + blockClear(cursorCol + cellsToMove, cursorRow, cellsToDelete) + } + 'S'.code -> { + val linesToScroll = getArg0(1) + for (i in 0 until linesToScroll) + scrollDownOneLine() + } + 'T'.code -> { + if (mArgIndex == 0) { + val linesToScrollArg = getArg0(1) + val linesBetweenTopAndBottomMargins = mBottomMargin - mTopMargin + val linesToScroll = minOf(linesBetweenTopAndBottomMargins, linesToScrollArg) + screen.blockCopy(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin, linesBetweenTopAndBottomMargins - linesToScroll, mLeftMargin, mTopMargin + linesToScroll) + blockClear(mLeftMargin, mTopMargin, mRightMargin - mLeftMargin, linesToScroll) + } else { + unimplementedSequence(b) + } + } + 'X'.code -> { + mAboutToAutoWrap = false + screen.blockSet(cursorCol, cursorRow, minOf(getArg0(1), mColumns - cursorCol), 1, ' '.code, style) + } + 'Z'.code -> { + var numberOfTabs = getArg0(1) + var newCol = mLeftMargin + for (i in cursorCol - 1 downTo 0) + if (mTabStop[i]) { + if (--numberOfTabs == 0) { + newCol = maxOf(i, mLeftMargin) + break + } + } + cursorCol = newCol + } + '?'.code -> continueSequence(ESC_CSI_QUESTIONMARK) + '>'.code -> continueSequence(ESC_CSI_BIGGERTHAN) + '<'.code, '='.code -> continueSequence(ESC_CSI_UNSUPPORTED_PARAMETER_BYTE) + '`'.code -> setCursorColRespectingOriginMode(getArg0(1) - 1) + 'b'.code -> { + if (mLastEmittedCodePoint == -1) return + val numRepeat = getArg0(1) + for (i in 0 until numRepeat) emitCodePoint(mLastEmittedCodePoint) + } + 'c'.code -> { /* Primary device attributes - ignored for read-only */ } + 'd'.code -> setCursorRow(minOf(maxOf(1, getArg0(1)), mRows) - 1) + 'e'.code -> setCursorPosition(cursorCol, cursorRow + getArg0(1)) + 'g'.code -> { + when (getArg0(0)) { + 0 -> mTabStop[cursorCol] = false + 3 -> for (i in 0 until mColumns) mTabStop[i] = false + } + } + 'h'.code -> doSetMode(true) + 'l'.code -> doSetMode(false) + 'm'.code -> selectGraphicRendition() + 'n'.code -> { /* Device Status Report - ignored for read-only */ } + 'r'.code -> { + mTopMargin = maxOf(0, minOf(getArg0(1) - 1, mRows - 2)) + mBottomMargin = maxOf(mTopMargin + 2, minOf(getArg1(mRows), mRows)) + setCursorPosition(0, 0) + } + 's'.code -> { + if (isDecsetInternalBitSet(DECSET_BIT_LEFTRIGHT_MARGIN_MODE)) { + mLeftMargin = minOf(getArg0(1) - 1, mColumns - 2) + mRightMargin = maxOf(mLeftMargin + 1, minOf(getArg1(mColumns), mColumns)) + setCursorPosition(0, 0) + } else { + saveCursor() + } + } + 't'.code -> { + when (getArg0(0)) { + 22 -> { + titleStack.push(title) + if (titleStack.size > 20) { + titleStack.removeAt(0) + } + } + 23 -> if (titleStack.isNotEmpty()) setTitle(titleStack.pop()) + } + } + 'u'.code -> restoreCursor() + ' '.code -> continueSequence(ESC_CSI_ARGS_SPACE) + else -> parseArg(b) + } + } + + private fun selectGraphicRendition() { + if (mArgIndex >= mArgs.size) mArgIndex = mArgs.size - 1 + var i = 0 + while (i <= mArgIndex) { + if ((mArgsSubParamsBitSet and (1 shl i)) != 0) { + i++ + continue + } + + var code = getArg(i, 0, false) + if (code < 0) { + if (mArgIndex > 0) { + i++ + continue + } else { + code = 0 + } + } + when { + code == 0 -> { + mForeColor = TextStyle.COLOR_INDEX_FOREGROUND + mBackColor = TextStyle.COLOR_INDEX_BACKGROUND + mEffect = 0 + } + code == 1 -> mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_BOLD + code == 2 -> mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_DIM + code == 3 -> mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_ITALIC + code == 4 -> { + if (i + 1 <= mArgIndex && ((mArgsSubParamsBitSet and (1 shl (i + 1))) != 0)) { + i++ + if (mArgs[i] == 0) { + mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE.inv() + } else { + mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE + } + } else { + mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE + } + } + code == 5 -> mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_BLINK + code == 7 -> mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_INVERSE + code == 8 -> mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE + code == 9 -> mEffect = mEffect or TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH + code == 10 -> { /* Exit alt charset (TERM=linux) - ignore */ } + code == 11 -> { /* Enter alt charset (TERM=linux) - ignore */ } + code == 22 -> mEffect = mEffect and (TextStyle.CHARACTER_ATTRIBUTE_BOLD or TextStyle.CHARACTER_ATTRIBUTE_DIM).inv() + code == 23 -> mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_ITALIC.inv() + code == 24 -> mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE.inv() + code == 25 -> mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_BLINK.inv() + code == 27 -> mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_INVERSE.inv() + code == 28 -> mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE.inv() + code == 29 -> mEffect = mEffect and TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH.inv() + code in 30..37 -> mForeColor = code - 30 + code == 38 || code == 48 || code == 58 -> { + if (i + 2 > mArgIndex) { i++; continue } + val firstArg = mArgs[i + 1] + if (firstArg == 2) { + if (i + 4 > mArgIndex) { + Timber.tag(LOG_TAG).w("Too few CSI${code};2 RGB arguments") + } else { + val red = getArg(i + 2, 0, false) + val green = getArg(i + 3, 0, false) + val blue = getArg(i + 4, 0, false) + if (red < 0 || green < 0 || blue < 0 || red > 255 || green > 255 || blue > 255) { + finishSequenceAndLogError("Invalid RGB: $red,$green,$blue") + } else { + val argbColor = 0xff000000.toInt() or (red shl 16) or (green shl 8) or blue + when (code) { + 38 -> mForeColor = argbColor + 48 -> mBackColor = argbColor + 58 -> mUnderlineColor = argbColor + } + } + i += 4 + } + } else if (firstArg == 5) { + val color = getArg(i + 2, 0, false) + i += 2 + if (color in 0 until TextStyle.NUM_INDEXED_COLORS) { + when (code) { + 38 -> mForeColor = color + 48 -> mBackColor = color + 58 -> mUnderlineColor = color + } + } else { + if (LOG_ESCAPE_SEQUENCES) Timber.tag(LOG_TAG).w("Invalid color index: $color") + } + } else { + finishSequenceAndLogError("Invalid ISO-8613-3 SGR first argument: $firstArg") + } + } + code == 39 -> mForeColor = TextStyle.COLOR_INDEX_FOREGROUND + code in 40..47 -> mBackColor = code - 40 + code == 49 -> mBackColor = TextStyle.COLOR_INDEX_BACKGROUND + code == 59 -> mUnderlineColor = TextStyle.COLOR_INDEX_FOREGROUND + code in 90..97 -> mForeColor = code - 90 + 8 + code in 100..107 -> mBackColor = code - 100 + 8 + else -> { + if (LOG_ESCAPE_SEQUENCES) + Timber.tag(LOG_TAG).w(String.format("SGR unknown code %d", code)) + } + } + i++ + } + } + + private fun doOsc(b: Int) { + when (b) { + 7 -> doOscSetTextParameters("\u0007") + 27 -> continueSequence(ESC_OSC_ESC) + else -> collectOSCArgs(b) + } + } + + private fun doOscEsc(b: Int) { + when (b) { + '\\'.code -> doOscSetTextParameters("\u001b\\") + else -> { + collectOSCArgs(27) + collectOSCArgs(b) + continueSequence(ESC_OSC) + } + } + } + + private fun doOscSetTextParameters(bellOrStringTerminator: String) { + var value = -1 + var textParameter = "" + for (idx in 0 until mOSCOrDeviceControlArgs.length) { + val b = mOSCOrDeviceControlArgs[idx] + if (b == ';') { + textParameter = mOSCOrDeviceControlArgs.substring(idx + 1) + break + } else if (b in '0'..'9') { + value = (if (value < 0) 0 else value * 10) + (b - '0') + } else { + unknownSequence(b.code) + return + } + } + + when (value) { + 0, 1, 2 -> setTitle(textParameter) + 4 -> { + var colorIndex = -1 + var parsingPairStart = -1 + var i = 0 + while (true) { + val endOfInput = i == textParameter.length + val ch = if (endOfInput) ';' else textParameter[i] + if (ch == ';') { + if (parsingPairStart < 0) { + parsingPairStart = i + 1 + } else { + if (colorIndex < 0 || colorIndex > 255) { + unknownSequence(ch.code) + return + } else { + mColors.tryParseColor(colorIndex, textParameter.substring(parsingPairStart, i)) + colorIndex = -1 + parsingPairStart = -1 + } + } + } else if (parsingPairStart >= 0) { + // Passing through color spec + } else if (parsingPairStart < 0 && ch in '0'..'9') { + colorIndex = (if (colorIndex < 0) 0 else colorIndex * 10) + (ch - '0') + } else { + unknownSequence(ch.code) + return + } + if (endOfInput) break + i++ + } + } + 10, 11, 12 -> { + var specialIndex = TextStyle.COLOR_INDEX_FOREGROUND + (value - 10) + var lastSemiIndex = 0 + var charIndex = 0 + while (true) { + val endOfInput = charIndex == textParameter.length + if (endOfInput || textParameter[charIndex] == ';') { + try { + val colorSpec = textParameter.substring(lastSemiIndex, charIndex) + if ("?" != colorSpec) { + mColors.tryParseColor(specialIndex, colorSpec) + } + specialIndex++ + charIndex++ + if (endOfInput || specialIndex > TextStyle.COLOR_INDEX_CURSOR || charIndex >= textParameter.length) + break + lastSemiIndex = charIndex + } catch (_: NumberFormatException) { + // Ignore + } + } + charIndex++ + } + } + 52 -> { + val startIndex = textParameter.indexOf(";") + 1 + try { + val clipboardText = String(Base64.decode(textParameter.substring(startIndex), 0), Charsets.UTF_8) + onCopyToClipboard?.invoke(clipboardText) + } catch (_: Exception) { + Timber.tag(LOG_TAG).e("OSC Manipulate selection, invalid string '$textParameter'") + } + } + 104 -> { + if (textParameter.isEmpty()) { + mColors.reset() + } else { + var lastIndex = 0 + var charIndex = 0 + while (true) { + val endOfInput = charIndex == textParameter.length + if (endOfInput || textParameter[charIndex] == ';') { + try { + val colorToReset = textParameter.substring(lastIndex, charIndex).toInt() + mColors.reset(colorToReset) + if (endOfInput) break + charIndex++ + lastIndex = charIndex + } catch (_: NumberFormatException) { + // Ignore + } + } + charIndex++ + } + } + } + 110, 111, 112 -> { + mColors.reset(TextStyle.COLOR_INDEX_FOREGROUND + (value - 110)) + } + 119 -> { /* Reset highlight color - ignore */ } + else -> unknownParameter(value) + } + finishSequence() + } + + private fun blockClear(sx: Int, sy: Int, w: Int) { + blockClear(sx, sy, w, 1) + } + + private fun blockClear(sx: Int, sy: Int, w: Int, h: Int) { + screen.blockSet(sx, sy, w, h, ' '.code, style) + } + + private val style: Long get() = TextStyle.encode(mForeColor, mBackColor, mEffect) + + private fun doSetMode(newValue: Boolean) { + val modeBit = getArg0(0) + when (modeBit) { + 4 -> mInsertMode = newValue + 20 -> unknownParameter(modeBit) + 34 -> { /* Normal cursor visibility - ignore */ } + else -> unknownParameter(modeBit) + } + } + + private fun setCursorPosition(x: Int, y: Int) { + val originMode = isDecsetInternalBitSet(DECSET_BIT_ORIGIN_MODE) + val effectiveTopMargin = if (originMode) mTopMargin else 0 + val effectiveBottomMargin = if (originMode) mBottomMargin else mRows + val effectiveLeftMargin = if (originMode) mLeftMargin else 0 + val effectiveRightMargin = if (originMode) mRightMargin else mColumns + val newRow = maxOf(effectiveTopMargin, minOf(effectiveTopMargin + y, effectiveBottomMargin - 1)) + val newCol = maxOf(effectiveLeftMargin, minOf(effectiveLeftMargin + x, effectiveRightMargin - 1)) + setCursorRowCol(newRow, newCol) + } + + private fun scrollDownOneLine() { + scrollCounter++ + val currentStyle = style + if (mLeftMargin != 0 || mRightMargin != mColumns) { + screen.blockCopy(mLeftMargin, mTopMargin + 1, mRightMargin - mLeftMargin, mBottomMargin - mTopMargin - 1, mLeftMargin, mTopMargin) + screen.blockSet(mLeftMargin, mBottomMargin - 1, mRightMargin - mLeftMargin, 1, ' '.code, currentStyle) + } else { + screen.scrollDownOneLine(mTopMargin, mBottomMargin, currentStyle) + } + } + + private fun parseArg(b: Int) { + if (b >= '0'.code && b <= '9'.code) { + if (mArgIndex < mArgs.size) { + val oldValue = mArgs[mArgIndex] + val thisDigit = b - '0'.code + val value: Int = if (oldValue >= 0) { + oldValue * 10 + thisDigit + } else { + thisDigit + } + mArgs[mArgIndex] = if (value > 9999) 9999 else value + } + continueSequence(mEscapeState) + } else if (b == ';'.code || b == ':'.code) { + if (mArgIndex + 1 < mArgs.size) { + mArgIndex++ + if (b == ':'.code) { + mArgsSubParamsBitSet = mArgsSubParamsBitSet or (1 shl mArgIndex) + } + } else { + logError("Too many parameters when in state: $mEscapeState") + } + continueSequence(mEscapeState) + } else { + unknownSequence(b) + } + } + + private fun getArg0(defaultValue: Int): Int = getArg(0, defaultValue, true) + + private fun getArg1(defaultValue: Int): Int = getArg(1, defaultValue, true) + + private fun getArg(index: Int, defaultValue: Int, treatZeroAsDefault: Boolean): Int { + var result = mArgs[index] + if (result < 0 || (result == 0 && treatZeroAsDefault)) { + result = defaultValue + } + return result + } + + private fun collectOSCArgs(b: Int) { + if (mOSCOrDeviceControlArgs.length < MAX_OSC_STRING_LENGTH) { + mOSCOrDeviceControlArgs.appendCodePoint(b) + continueSequence(mEscapeState) + } else { + unknownSequence(b) + } + } + + private fun unimplementedSequence(b: Int) { + logError("Unimplemented sequence char '${b.toChar()}' (U+${String.format("%04x", b)})") + finishSequence() + } + + private fun unknownSequence(b: Int) { + logError("Unknown sequence char '${b.toChar()}' (numeric value=$b)") + finishSequence() + } + + private fun unknownParameter(parameter: Int) { + logError("Unknown parameter: $parameter") + finishSequence() + } + + private fun logError(errorType: String) { + if (LOG_ESCAPE_SEQUENCES) { + val buf = StringBuilder() + buf.append(errorType) + buf.append(", escapeState=") + buf.append(mEscapeState) + var firstArg = true + if (mArgIndex >= mArgs.size) mArgIndex = mArgs.size - 1 + for (i in 0..mArgIndex) { + val value = mArgs[i] + if (value >= 0) { + if (firstArg) { + firstArg = false + buf.append(", args={") + } else { + buf.append(',') + } + buf.append(value) + } + } + if (!firstArg) buf.append('}') + finishSequenceAndLogError(buf.toString()) + } + } + + private fun finishSequenceAndLogError(error: String) { + if (LOG_ESCAPE_SEQUENCES) Timber.tag(LOG_TAG).w(error) + finishSequence() + } + + private fun finishSequence() { + mEscapeState = ESC_NONE + } + + private fun emitCodePoint(codePoint: Int) { + var cp = codePoint + mLastEmittedCodePoint = cp + if (if (mUseLineDrawingUsesG0) mUseLineDrawingG0 else mUseLineDrawingG1) { + when (cp) { + '_'.code -> cp = ' '.code + '`'.code -> cp = '\u25C6'.code // Diamond + '0'.code -> cp = '\u2588'.code // Solid block + 'a'.code -> cp = '\u2592'.code // Checker board + 'b'.code -> cp = '\u2409'.code // Horizontal tab + 'c'.code -> cp = '\u240C'.code // Form feed + 'd'.code -> cp = '\r'.code // Carriage return + 'e'.code -> cp = '\u240A'.code // Linefeed + 'f'.code -> cp = '\u00B0'.code // Degree + 'g'.code -> cp = '\u00B1'.code // Plus-minus + 'h'.code -> cp = '\n'.code // Newline + 'i'.code -> cp = '\u240B'.code // Vertical tab + 'j'.code -> cp = '\u2518'.code // Lower right corner + 'k'.code -> cp = '\u2510'.code // Upper right corner + 'l'.code -> cp = '\u250C'.code // Upper left corner + 'm'.code -> cp = '\u2514'.code // Lower left corner + 'n'.code -> cp = '\u253C'.code // Crossing lines + 'o'.code -> cp = '\u23BA'.code // Horizontal line - scan 1 + 'p'.code -> cp = '\u23BB'.code // Horizontal line - scan 3 + 'q'.code -> cp = '\u2500'.code // Horizontal line - scan 5 + 'r'.code -> cp = '\u23BC'.code // Horizontal line - scan 7 + 's'.code -> cp = '\u23BD'.code // Horizontal line - scan 9 + 't'.code -> cp = '\u251C'.code // T facing rightwards + 'u'.code -> cp = '\u2524'.code // T facing leftwards + 'v'.code -> cp = '\u2534'.code // T facing upwards + 'w'.code -> cp = '\u252C'.code // T facing downwards + 'x'.code -> cp = '\u2502'.code // Vertical line + 'y'.code -> cp = '\u2264'.code // Less than or equal to + 'z'.code -> cp = '\u2265'.code // Greater than or equal to + '{'.code -> cp = '\u03C0'.code // Pi + '|'.code -> cp = '\u2260'.code // Not equal to + '}'.code -> cp = '\u00A3'.code // UK pound + '~'.code -> cp = '\u00B7'.code // Centered dot + } + } + + val autoWrap = isDecsetInternalBitSet(DECSET_BIT_AUTOWRAP) + val displayWidth = WcWidth.width(cp) + val cursorInLastColumn = cursorCol == mRightMargin - 1 + + if (autoWrap) { + if (cursorInLastColumn && ((mAboutToAutoWrap && displayWidth == 1) || displayWidth == 2)) { + screen.setLineWrap(cursorRow) + cursorCol = mLeftMargin + if (cursorRow + 1 < mBottomMargin) { + cursorRow++ + } else { + scrollDownOneLine() + } + } + } else if (cursorInLastColumn && displayWidth == 2) { + return + } + + if (mInsertMode && displayWidth > 0) { + val destCol = cursorCol + displayWidth + if (destCol < mRightMargin) + screen.blockCopy(cursorCol, cursorRow, mRightMargin - destCol, 1, destCol, cursorRow) + } + + val offsetDueToCombiningChar = if (displayWidth <= 0 && cursorCol > 0 && !mAboutToAutoWrap) 1 else 0 + var column = cursorCol - offsetDueToCombiningChar + + if (column < 0) column = 0 + screen.setChar(column, cursorRow, cp, style) + + if (autoWrap && displayWidth > 0) + mAboutToAutoWrap = (cursorCol == mRightMargin - displayWidth) + + cursorCol = minOf(cursorCol + displayWidth, mRightMargin - 1) + } + + private fun setCursorRow(row: Int) { + cursorRow = row + mAboutToAutoWrap = false + } + + private fun setCursorCol(col: Int) { + cursorCol = col + mAboutToAutoWrap = false + } + + private fun setCursorColRespectingOriginMode(col: Int) { + setCursorPosition(col, cursorRow) + } + + private fun setCursorRowCol(row: Int, col: Int) { + cursorRow = maxOf(0, minOf(row, mRows - 1)) + cursorCol = maxOf(0, minOf(col, mColumns - 1)) + mAboutToAutoWrap = false + } + + + fun clearScrollCounter() { + scrollCounter = 0 + } + + + fun toggleAutoScrollDisabled() { + isAutoScrollDisabled = !isAutoScrollDisabled + } + + fun reset() { + setCursorStyle() + mArgIndex = 0 + mContinueSequence = false + mEscapeState = ESC_NONE + mInsertMode = false + mTopMargin = 0 + mLeftMargin = 0 + mBottomMargin = mRows + mRightMargin = mColumns + mAboutToAutoWrap = false + mForeColor = TextStyle.COLOR_INDEX_FOREGROUND + mSavedStateMain.mSavedForeColor = TextStyle.COLOR_INDEX_FOREGROUND + mSavedStateAlt.mSavedForeColor = TextStyle.COLOR_INDEX_FOREGROUND + mBackColor = TextStyle.COLOR_INDEX_BACKGROUND + mSavedStateMain.mSavedBackColor = TextStyle.COLOR_INDEX_BACKGROUND + mSavedStateAlt.mSavedBackColor = TextStyle.COLOR_INDEX_BACKGROUND + setDefaultTabStops() + + mUseLineDrawingG0 = false + mUseLineDrawingG1 = false + mUseLineDrawingUsesG0 = true + + mSavedStateMain.mSavedCursorRow = 0 + mSavedStateMain.mSavedCursorCol = 0 + mSavedStateMain.mSavedEffect = 0 + mSavedStateMain.mSavedDecFlags = 0 + mSavedStateAlt.mSavedCursorRow = 0 + mSavedStateAlt.mSavedCursorCol = 0 + mSavedStateAlt.mSavedEffect = 0 + mSavedStateAlt.mSavedDecFlags = 0 + mCurrentDecSetFlags = 0 + setDecsetinternalBit(DECSET_BIT_AUTOWRAP, true) + setDecsetinternalBit(DECSET_BIT_CURSOR_ENABLED, true) + mSavedDecSetFlags = mCurrentDecSetFlags + mSavedStateMain.mSavedDecFlags = mCurrentDecSetFlags + mSavedStateAlt.mSavedDecFlags = mCurrentDecSetFlags + + mUtf8Index = 0 + mUtf8ToFollow = 0 + + mColors.reset() + } + + fun getSelectedText(x1: Int, y1: Int, x2: Int, y2: Int): String = + screen.getSelectedText(x1, y1, x2, y2) + + + private fun setTitle(newTitle: String?) { + title = newTitle + } + + internal class SavedScreenState { + var mSavedCursorRow = 0 + var mSavedCursorCol = 0 + var mSavedEffect = 0 + var mSavedForeColor = 0 + var mSavedBackColor = 0 + var mSavedDecFlags = 0 + var mUseLineDrawingG0 = false + var mUseLineDrawingG1 = false + var mUseLineDrawingUsesG0 = true + } + + override fun toString(): String = + "TerminalEmulator[size=${screen.columns}x${screen.screenRows}, margins={$mTopMargin,$mRightMargin,$mBottomMargin,$mLeftMargin}]" +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalProcess.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalProcess.kt new file mode 100644 index 000000000..76adbf351 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalProcess.kt @@ -0,0 +1,62 @@ +package com.topjohnwu.magisk.terminal + +import android.os.Handler +import android.os.Looper +import com.topjohnwu.superuser.Shell +import timber.log.Timber + +private val busyboxPath: String by lazy { + Shell.cmd("readlink /proc/self/exe").exec().out.firstOrNull() + ?: "/data/adb/magisk/busybox" +} + +private val mainHandler = Handler(Looper.getMainLooper()) + +fun TerminalEmulator.appendOnMain(bytes: ByteArray, len: Int) { + mainHandler.post { + append(bytes, len) + onScreenUpdate?.invoke() + } +} + +fun TerminalEmulator.appendLineOnMain(line: String) { + val bytes = "$line\r\n".toByteArray(Charsets.UTF_8) + appendOnMain(bytes, bytes.size) +} + +/** + * Run a command as root inside a PTY (via busybox script). + * Reads raw bytes from the process and feeds them to the terminal emulator. + * Must be called from a background thread. + * Returns true if the process exits with code 0. + */ +fun runSuCommand(emulator: TerminalEmulator, command: String): Boolean { + return try { + val cols = emulator.mColumns + val rows = emulator.mRows + val wrappedCmd = "export TERM=xterm-256color; stty cols $cols rows $rows 2>/dev/null; $command" + val escapedCmd = wrappedCmd.replace("'", "'\\''") + + val process = ProcessBuilder( + "su", "-c", + "$busyboxPath script -q -c '$escapedCmd' /dev/null" + ).redirectErrorStream(true).start() + + process.outputStream.close() + + val buffer = ByteArray(4096) + process.inputStream.use { input -> + while (true) { + val n = input.read(buffer) + if (n == -1) break + emulator.appendOnMain(buffer.copyOf(n), n) + } + } + + process.waitFor() == 0 + } catch (e: Exception) { + Timber.e(e, "runSuCommand failed") + emulator.appendLineOnMain("! Error: ${e.message}") + false + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalRow.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalRow.kt new file mode 100644 index 000000000..34e7b9733 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalRow.kt @@ -0,0 +1,267 @@ +package com.topjohnwu.magisk.terminal + +import java.util.Arrays + +/** + * A row in a terminal, composed of a fixed number of cells. + * + * The text in the row is stored in a char[] array, [text], for quick access during rendering. + */ +class TerminalRow(private val columns: Int, style: Long) { + + /** + * Max combining characters that can exist in a column, that are separate from the base character + * itself. Any additional combining characters will be ignored and not added to the column. + * + * There does not seem to be limit in unicode standard for max number of combination characters + * that can be combined but such characters are primarily under 10. + * + * "Section 3.6 Combination" of unicode standard contains combining characters info. + * - https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf + * - https://en.wikipedia.org/wiki/Combining_character#Unicode_ranges + * - https://stackoverflow.com/questions/71237212/what-is-the-maximum-number-of-unicode-combined-characters-that-may-be-needed-to + * + * UAX15-D3 Stream-Safe Text Format limits to max 30 combining characters. + * > The value of 30 is chosen to be significantly beyond what is required for any linguistic or technical usage. + * > While it would have been feasible to chose a smaller number, this value provides a very wide margin, + * > yet is well within the buffer size limits of practical implementations. + * - https://unicode.org/reports/tr15/#Stream_Safe_Text_Format + * - https://stackoverflow.com/a/11983435/14686958 + * + * We choose the value 15 because it should be enough for terminal based applications and keep + * the memory usage low for a terminal row, won't affect performance or cause terminal to + * lag or hang, and will keep malicious applications from causing harm. The value can be + * increased if ever needed for legitimate applications. + */ + companion object { + private const val SPARE_CAPACITY_FACTOR = 1.5f + private const val MAX_COMBINING_CHARACTERS_PER_COLUMN = 15 + } + + /** The text filling this terminal row. */ + var text: CharArray = CharArray((SPARE_CAPACITY_FACTOR * columns).toInt()) + + /** The number of java chars used in [text]. */ + private var _spaceUsed: Short = 0 + + /** If this row has been line wrapped due to text output at the end of line. */ + var lineWrap: Boolean = false + + /** The style bits of each cell in the row. See [TextStyle]. */ + val styles: LongArray = LongArray(columns) + + /** If this row might contain chars with width != 1, used for deactivating fast path */ + var hasNonOneWidthOrSurrogateChars: Boolean = false + + init { + clear(style) + } + + /** NOTE: The sourceX2 is exclusive. */ + fun copyInterval(line: TerminalRow, sourceX1: Int, sourceX2: Int, destinationX: Int) { + hasNonOneWidthOrSurrogateChars = hasNonOneWidthOrSurrogateChars or line.hasNonOneWidthOrSurrogateChars + val x1 = line.findStartOfColumn(sourceX1) + val x2 = line.findStartOfColumn(sourceX2) + var startingFromSecondHalfOfWideChar = sourceX1 > 0 && line.wideDisplayCharacterStartingAt(sourceX1 - 1) + val sourceChars = if (this === line) line.text.copyOf() else line.text + var latestNonCombiningWidth = 0 + var destX = destinationX + var srcX1 = sourceX1 + var i = x1 + while (i < x2) { + val sourceChar = sourceChars[i] + var codePoint: Int + if (Character.isHighSurrogate(sourceChar)) { + i++ + codePoint = Character.toCodePoint(sourceChar, sourceChars[i]) + } else { + codePoint = sourceChar.code + } + if (startingFromSecondHalfOfWideChar) { + codePoint = ' '.code + startingFromSecondHalfOfWideChar = false + } + val w = WcWidth.width(codePoint) + if (w > 0) { + destX += latestNonCombiningWidth + srcX1 += latestNonCombiningWidth + latestNonCombiningWidth = w + } + setChar(destX, codePoint, line.getStyle(srcX1)) + i++ + } + } + + val spaceUsed: Int get() = _spaceUsed.toInt() + + /** Note that the column may end of second half of wide character. */ + fun findStartOfColumn(column: Int): Int { + if (column == columns) return spaceUsed + + var currentColumn = 0 + var currentCharIndex = 0 + while (true) { + var newCharIndex = currentCharIndex + val c = text[newCharIndex++] + val isHigh = Character.isHighSurrogate(c) + val codePoint = if (isHigh) Character.toCodePoint(c, text[newCharIndex++]) else c.code + val wcwidth = WcWidth.width(codePoint) + if (wcwidth > 0) { + currentColumn += wcwidth + if (currentColumn == column) { + while (newCharIndex < _spaceUsed) { + if (Character.isHighSurrogate(text[newCharIndex])) { + if (WcWidth.width(Character.toCodePoint(text[newCharIndex], text[newCharIndex + 1])) <= 0) { + newCharIndex += 2 + } else { + break + } + } else if (WcWidth.width(text[newCharIndex].code) <= 0) { + newCharIndex++ + } else { + break + } + } + return newCharIndex + } else if (currentColumn > column) { + return currentCharIndex + } + } + currentCharIndex = newCharIndex + } + } + + private fun wideDisplayCharacterStartingAt(column: Int): Boolean { + var currentCharIndex = 0 + var currentColumn = 0 + while (currentCharIndex < _spaceUsed) { + val c = text[currentCharIndex++] + val codePoint = if (Character.isHighSurrogate(c)) Character.toCodePoint(c, text[currentCharIndex++]) else c.code + val wcwidth = WcWidth.width(codePoint) + if (wcwidth > 0) { + if (currentColumn == column && wcwidth == 2) return true + currentColumn += wcwidth + if (currentColumn > column) return false + } + } + return false + } + + fun clear(style: Long) { + Arrays.fill(text, ' ') + Arrays.fill(styles, style) + _spaceUsed = columns.toShort() + hasNonOneWidthOrSurrogateChars = false + } + + // https://github.com/steven676/Android-Terminal-Emulator/commit/9a47042620bec87617f0b4f5d50568535668fe26 + fun setChar(columnToSet: Int, codePoint: Int, style: Long) { + if (columnToSet < 0 || columnToSet >= styles.size) + throw IllegalArgumentException("TerminalRow.setChar(): columnToSet=$columnToSet, codePoint=$codePoint, style=$style") + + styles[columnToSet] = style + + val newCodePointDisplayWidth = WcWidth.width(codePoint) + + // Fast path when we don't have any chars with width != 1 + if (!hasNonOneWidthOrSurrogateChars) { + if (codePoint >= Character.MIN_SUPPLEMENTARY_CODE_POINT || newCodePointDisplayWidth != 1) { + hasNonOneWidthOrSurrogateChars = true + } else { + text[columnToSet] = codePoint.toChar() + return + } + } + + val newIsCombining = newCodePointDisplayWidth <= 0 + + val wasExtraColForWideChar = columnToSet > 0 && wideDisplayCharacterStartingAt(columnToSet - 1) + + var col = columnToSet + if (newIsCombining) { + if (wasExtraColForWideChar) col-- + } else { + if (wasExtraColForWideChar) setChar(col - 1, ' '.code, style) + val overwritingWideCharInNextColumn = newCodePointDisplayWidth == 2 && wideDisplayCharacterStartingAt(col + 1) + if (overwritingWideCharInNextColumn) setChar(col + 1, ' '.code, style) + } + + var textArray = text + val oldStartOfColumnIndex = findStartOfColumn(col) + val oldCodePointDisplayWidth = WcWidth.width(textArray, oldStartOfColumnIndex) + + val oldCharactersUsedForColumn: Int + if (col + oldCodePointDisplayWidth < columns) { + val oldEndOfColumnIndex = findStartOfColumn(col + oldCodePointDisplayWidth) + oldCharactersUsedForColumn = oldEndOfColumnIndex - oldStartOfColumnIndex + } else { + oldCharactersUsedForColumn = _spaceUsed - oldStartOfColumnIndex + } + + if (newIsCombining) { + val combiningCharsCount = WcWidth.zeroWidthCharsCount(textArray, oldStartOfColumnIndex, oldStartOfColumnIndex + oldCharactersUsedForColumn) + if (combiningCharsCount >= MAX_COMBINING_CHARACTERS_PER_COLUMN) + return + } + + var newCharactersUsedForColumn = Character.charCount(codePoint) + if (newIsCombining) { + newCharactersUsedForColumn += oldCharactersUsedForColumn + } + + val oldNextColumnIndex = oldStartOfColumnIndex + oldCharactersUsedForColumn + val newNextColumnIndex = oldStartOfColumnIndex + newCharactersUsedForColumn + + val javaCharDifference = newCharactersUsedForColumn - oldCharactersUsedForColumn + if (javaCharDifference > 0) { + val oldCharactersAfterColumn = _spaceUsed - oldNextColumnIndex + if (_spaceUsed + javaCharDifference > textArray.size) { + val newText = CharArray(textArray.size + columns) + System.arraycopy(textArray, 0, newText, 0, oldNextColumnIndex) + System.arraycopy(textArray, oldNextColumnIndex, newText, newNextColumnIndex, oldCharactersAfterColumn) + text = newText + textArray = newText + } else { + System.arraycopy(textArray, oldNextColumnIndex, textArray, newNextColumnIndex, oldCharactersAfterColumn) + } + } else if (javaCharDifference < 0) { + System.arraycopy(textArray, oldNextColumnIndex, textArray, newNextColumnIndex, _spaceUsed - oldNextColumnIndex) + } + _spaceUsed = (_spaceUsed + javaCharDifference).toShort() + + Character.toChars(codePoint, textArray, oldStartOfColumnIndex + if (newIsCombining) oldCharactersUsedForColumn else 0) + + if (oldCodePointDisplayWidth == 2 && newCodePointDisplayWidth == 1) { + if (_spaceUsed + 1 > textArray.size) { + val newText = CharArray(textArray.size + columns) + System.arraycopy(textArray, 0, newText, 0, newNextColumnIndex) + System.arraycopy(textArray, newNextColumnIndex, newText, newNextColumnIndex + 1, _spaceUsed - newNextColumnIndex) + text = newText + textArray = newText + } else { + System.arraycopy(textArray, newNextColumnIndex, textArray, newNextColumnIndex + 1, _spaceUsed - newNextColumnIndex) + } + textArray[newNextColumnIndex] = ' ' + ++_spaceUsed + } else if (oldCodePointDisplayWidth == 1 && newCodePointDisplayWidth == 2) { + if (col == columns - 1) { + throw IllegalArgumentException("Cannot put wide character in last column") + } else if (col == columns - 2) { + _spaceUsed = newNextColumnIndex.toShort() + } else { + val newNextNextColumnIndex = newNextColumnIndex + if (Character.isHighSurrogate(textArray[newNextColumnIndex])) 2 else 1 + val nextLen = newNextNextColumnIndex - newNextColumnIndex + System.arraycopy(textArray, newNextNextColumnIndex, textArray, newNextColumnIndex, _spaceUsed - newNextNextColumnIndex) + _spaceUsed = (_spaceUsed - nextLen).toShort() + } + } + } + + internal fun isBlank(): Boolean { + for (charIndex in 0 until spaceUsed) + if (text[charIndex] != ' ') return false + return true + } + + fun getStyle(column: Int): Long = styles[column] +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalStyle.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalStyle.kt new file mode 100644 index 000000000..55bae94e2 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/TerminalStyle.kt @@ -0,0 +1,246 @@ +package com.topjohnwu.magisk.terminal + +import android.graphics.Color +import java.util.Properties +import kotlin.math.floor +import kotlin.math.pow +import kotlin.math.sqrt + +object TextStyle { + + const val CHARACTER_ATTRIBUTE_BOLD = 1 + const val CHARACTER_ATTRIBUTE_ITALIC = 1 shl 1 + const val CHARACTER_ATTRIBUTE_UNDERLINE = 1 shl 2 + const val CHARACTER_ATTRIBUTE_BLINK = 1 shl 3 + const val CHARACTER_ATTRIBUTE_INVERSE = 1 shl 4 + const val CHARACTER_ATTRIBUTE_INVISIBLE = 1 shl 5 + const val CHARACTER_ATTRIBUTE_STRIKETHROUGH = 1 shl 6 + const val CHARACTER_ATTRIBUTE_PROTECTED = 1 shl 7 + const val CHARACTER_ATTRIBUTE_DIM = 1 shl 8 + private const val CHARACTER_ATTRIBUTE_TRUECOLOR_FOREGROUND = 1 shl 9 + private const val CHARACTER_ATTRIBUTE_TRUECOLOR_BACKGROUND = 1 shl 10 + + const val COLOR_INDEX_FOREGROUND = 256 + const val COLOR_INDEX_BACKGROUND = 257 + const val COLOR_INDEX_CURSOR = 258 + const val NUM_INDEXED_COLORS = 259 + + val NORMAL = encode(COLOR_INDEX_FOREGROUND, COLOR_INDEX_BACKGROUND, 0) + + fun encode(foreColor: Int, backColor: Int, effect: Int): Long { + var result = (effect and 0b111111111).toLong() + if (foreColor and 0xff000000.toInt() == 0xff000000.toInt()) { + result = result or CHARACTER_ATTRIBUTE_TRUECOLOR_FOREGROUND.toLong() or ((foreColor.toLong() and 0x00ffffffL) shl 40) + } else { + result = result or ((foreColor.toLong() and 0b111111111L) shl 40) + } + if (backColor and 0xff000000.toInt() == 0xff000000.toInt()) { + result = result or CHARACTER_ATTRIBUTE_TRUECOLOR_BACKGROUND.toLong() or ((backColor.toLong() and 0x00ffffffL) shl 16) + } else { + result = result or ((backColor.toLong() and 0b111111111L) shl 16) + } + return result + } + + fun decodeForeColor(style: Long): Int { + return if (style and CHARACTER_ATTRIBUTE_TRUECOLOR_FOREGROUND.toLong() == 0L) { + ((style ushr 40) and 0b111111111L).toInt() + } else { + 0xff000000.toInt() or ((style ushr 40) and 0x00ffffffL).toInt() + } + } + + fun decodeBackColor(style: Long): Int { + return if (style and CHARACTER_ATTRIBUTE_TRUECOLOR_BACKGROUND.toLong() == 0L) { + ((style ushr 16) and 0b111111111L).toInt() + } else { + 0xff000000.toInt() or ((style ushr 16) and 0x00ffffffL).toInt() + } + } + + fun decodeEffect(style: Long): Int { + return (style and 0b11111111111L).toInt() + } +} + +/** + * Color scheme for a terminal with default colors, which may be overridden (and then reset) from the shell using + * Operating System Control (OSC) sequences. + */ +class TerminalColorScheme { + + val defaultColors: IntArray = IntArray(TextStyle.NUM_INDEXED_COLORS) + + init { + reset() + } + + fun updateWith(props: Properties) { + reset() + var cursorPropExists = false + for ((keyObj, valueObj) in props) { + val key = keyObj as String + val value = valueObj as String + val colorIndex: Int = when { + key == "foreground" -> TextStyle.COLOR_INDEX_FOREGROUND + key == "background" -> TextStyle.COLOR_INDEX_BACKGROUND + key == "cursor" -> { + cursorPropExists = true + TextStyle.COLOR_INDEX_CURSOR + } + key.startsWith("color") -> { + try { + key.substring(5).toInt() + } catch (_: NumberFormatException) { + throw IllegalArgumentException("Invalid property: '$key'") + } + } + else -> throw IllegalArgumentException("Invalid property: '$key'") + } + + val colorValue = TerminalColors.parse(value) + if (colorValue == 0) { + throw IllegalArgumentException("Property '$key' has invalid color: '$value'") + } + + defaultColors[colorIndex] = colorValue + } + + if (!cursorPropExists) { + setCursorColorForBackground() + } + } + + fun setCursorColorForBackground() { + val backgroundColor = defaultColors[TextStyle.COLOR_INDEX_BACKGROUND] + val brightness = TerminalColors.perceivedBrightness(backgroundColor) + if (brightness > 0) { + defaultColors[TextStyle.COLOR_INDEX_CURSOR] = if (brightness < 130) { + 0xffffffff.toInt() + } else { + 0xff000000.toInt() + } + } + } + + private fun reset() { + System.arraycopy(DEFAULT_COLORSCHEME, 0, defaultColors, 0, TextStyle.NUM_INDEXED_COLORS) + } + + companion object { + private val DEFAULT_COLORSCHEME = longArrayOf( + // 16 original colors. First 8 are dim. + 0xff000000, // black + 0xffcd0000, // dim red + 0xff00cd00, // dim green + 0xffcdcd00, // dim yellow + 0xff6495ed, // dim blue + 0xffcd00cd, // dim magenta + 0xff00cdcd, // dim cyan + 0xffe5e5e5, // dim white + // Second 8 are bright: + 0xff7f7f7f, // medium grey + 0xffff0000, // bright red + 0xff00ff00, // bright green + 0xffffff00, // bright yellow + 0xff5c5cff, // light blue + 0xffff00ff, // bright magenta + 0xff00ffff, // bright cyan + 0xffffffffL, // bright white + + // 216 color cube, six shades of each color: + 0xff000000, 0xff00005f, 0xff000087, 0xff0000af, 0xff0000d7, 0xff0000ff, 0xff005f00, 0xff005f5f, 0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff, + 0xff008700, 0xff00875f, 0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff, 0xff00af00, 0xff00af5f, 0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff, + 0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff, 0xff00ff00, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7, 0xff00ffff, + 0xff5f0000, 0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff, 0xff5f5f00, 0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff, + 0xff5f8700, 0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00, 0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff, + 0xff5fd700, 0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00, 0xff5fff5f, 0xff5fff87, 0xff5fffaf, 0xff5fffd7, 0xff5fffff, + 0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7, 0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7, 0xff875fff, + 0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7, 0xff8787ff, 0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7, 0xff87afff, + 0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af, 0xff87d7d7, 0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87, 0xff87ffaf, 0xff87ffd7, 0xff87ffff, + 0xffaf0000, 0xffaf005f, 0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00, 0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff, + 0xffaf8700, 0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff, 0xffafaf00, 0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff, + 0xffafd700, 0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00, 0xffafff5f, 0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff, + 0xffd70000, 0xffd7005f, 0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f, 0xffd75f87, 0xffd75faf, 0xffd75fd7, 0xffd75fff, + 0xffd78700, 0xffd7875f, 0xffd78787, 0xffd787af, 0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f, 0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff, + 0xffd7d700, 0xffd7d75f, 0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00, 0xffd7ff5f, 0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff, + 0xffff0000, 0xffff005f, 0xffff0087, 0xffff00af, 0xffff00d7, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87, 0xffff5faf, 0xffff5fd7, 0xffff5fff, + 0xffff8700, 0xffff875f, 0xffff8787, 0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87, 0xffffafaf, 0xffffafd7, 0xffffafff, + 0xffffd700, 0xffffd75f, 0xffffd787, 0xffffd7af, 0xffffd7d7, 0xffffd7ff, 0xffffff00, 0xffffff5f, 0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffffL, + + // 24 grey scale ramp: + 0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626, 0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858, 0xff626262, 0xff6c6c6c, 0xff767676, + 0xff808080, 0xff8a8a8a, 0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffb2b2b2, 0xffbcbcbc, 0xffc6c6c6, 0xffd0d0d0, 0xffdadada, 0xffe4e4e4, 0xffeeeeee, + + // COLOR_INDEX_DEFAULT_FOREGROUND, COLOR_INDEX_DEFAULT_BACKGROUND and COLOR_INDEX_DEFAULT_CURSOR: + 0xffffffffL, 0xff000000L, 0xffffffffL + ).map { it.toInt() }.toIntArray() + } +} + +/** Current terminal colors (if different from default). */ +class TerminalColors { + + val currentColors: IntArray = IntArray(TextStyle.NUM_INDEXED_COLORS) + + init { + reset() + } + + fun reset(index: Int) { + currentColors[index] = COLOR_SCHEME.defaultColors[index] + } + + fun reset() { + System.arraycopy(COLOR_SCHEME.defaultColors, 0, currentColors, 0, TextStyle.NUM_INDEXED_COLORS) + } + + fun tryParseColor(intoIndex: Int, textParameter: String) { + val c = parse(textParameter) + if (c != 0) currentColors[intoIndex] = c + } + + companion object { + val COLOR_SCHEME = TerminalColorScheme() + + internal fun parse(c: String): Int { + return try { + val (skipInitial, skipBetween) = when { + c[0] == '#' -> 1 to 0 + c.startsWith("rgb:") -> 4 to 1 + else -> return 0 + } + val charsForColors = c.length - skipInitial - 2 * skipBetween + if (charsForColors % 3 != 0) return 0 + val componentLength = charsForColors / 3 + val mult = 255.0 / (2.0.pow(componentLength * 4) - 1) + + var currentPosition = skipInitial + val rString = c.substring(currentPosition, currentPosition + componentLength) + currentPosition += componentLength + skipBetween + val gString = c.substring(currentPosition, currentPosition + componentLength) + currentPosition += componentLength + skipBetween + val bString = c.substring(currentPosition, currentPosition + componentLength) + + val r = (rString.toInt(16) * mult).toInt() + val g = (gString.toInt(16) * mult).toInt() + val b = (bString.toInt(16) * mult).toInt() + (0xFF shl 24) or (r shl 16) or (g shl 8) or b + } catch (_: NumberFormatException) { + 0 + } catch (_: IndexOutOfBoundsException) { + 0 + } + } + + fun perceivedBrightness(color: Int): Int { + return floor( + sqrt( + Color.red(color).toDouble().pow(2) * 0.241 + + Color.green(color).toDouble().pow(2) * 0.691 + + Color.blue(color).toDouble().pow(2) * 0.068 + ) + ).toInt() + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/WcWidth.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/WcWidth.kt new file mode 100644 index 000000000..c3dfbf316 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/terminal/WcWidth.kt @@ -0,0 +1,559 @@ +package com.topjohnwu.magisk.terminal + +/** + * Implementation of wcwidth(3) for Unicode 15. + * + * Implementation from https://github.com/jquast/wcwidth but we return 0 for unprintable characters. + * + * IMPORTANT: + * Must be kept in sync with the following: + * https://github.com/termux/wcwidth + * https://github.com/termux/libandroid-support + * https://github.com/termux/termux-packages/tree/master/packages/libandroid-support + */ +object WcWidth { + + // From https://github.com/jquast/wcwidth/blob/master/wcwidth/table_zero.py + // from https://github.com/jquast/wcwidth/pull/64 + // at commit 1b9b6585b0080ea5cb88dc9815796505724793fe (2022-12-16): + private val ZERO_WIDTH = arrayOf( + intArrayOf(0x00300, 0x0036f), // Combining Grave Accent ..Combining Latin Small Le + intArrayOf(0x00483, 0x00489), // Combining Cyrillic Titlo..Combining Cyrillic Milli + intArrayOf(0x00591, 0x005bd), // Hebrew Accent Etnahta ..Hebrew Point Meteg + intArrayOf(0x005bf, 0x005bf), // Hebrew Point Rafe ..Hebrew Point Rafe + intArrayOf(0x005c1, 0x005c2), // Hebrew Point Shin Dot ..Hebrew Point Sin Dot + intArrayOf(0x005c4, 0x005c5), // Hebrew Mark Upper Dot ..Hebrew Mark Lower Dot + intArrayOf(0x005c7, 0x005c7), // Hebrew Point Qamats Qata..Hebrew Point Qamats Qata + intArrayOf(0x00610, 0x0061a), // Arabic Sign Sallallahou ..Arabic Small Kasra + intArrayOf(0x0064b, 0x0065f), // Arabic Fathatan ..Arabic Wavy Hamza Below + intArrayOf(0x00670, 0x00670), // Arabic Letter Superscrip..Arabic Letter Superscrip + intArrayOf(0x006d6, 0x006dc), // Arabic Small High Ligatu..Arabic Small High Seen + intArrayOf(0x006df, 0x006e4), // Arabic Small High Rounde..Arabic Small High Madda + intArrayOf(0x006e7, 0x006e8), // Arabic Small High Yeh ..Arabic Small High Noon + intArrayOf(0x006ea, 0x006ed), // Arabic Empty Centre Low ..Arabic Small Low Meem + intArrayOf(0x00711, 0x00711), // Syriac Letter Superscrip..Syriac Letter Superscrip + intArrayOf(0x00730, 0x0074a), // Syriac Pthaha Above ..Syriac Barrekh + intArrayOf(0x007a6, 0x007b0), // Thaana Abafili ..Thaana Sukun + intArrayOf(0x007eb, 0x007f3), // Nko Combining Short High..Nko Combining Double Dot + intArrayOf(0x007fd, 0x007fd), // Nko Dantayalan ..Nko Dantayalan + intArrayOf(0x00816, 0x00819), // Samaritan Mark In ..Samaritan Mark Dagesh + intArrayOf(0x0081b, 0x00823), // Samaritan Mark Epentheti..Samaritan Vowel Sign A + intArrayOf(0x00825, 0x00827), // Samaritan Vowel Sign Sho..Samaritan Vowel Sign U + intArrayOf(0x00829, 0x0082d), // Samaritan Vowel Sign Lon..Samaritan Mark Nequdaa + intArrayOf(0x00859, 0x0085b), // Mandaic Affrication Mark..Mandaic Gemination Mark + intArrayOf(0x00898, 0x0089f), // Arabic Small High Word A..Arabic Half Madda Over M + intArrayOf(0x008ca, 0x008e1), // Arabic Small High Farsi ..Arabic Small High Sign S + intArrayOf(0x008e3, 0x00902), // Arabic Turned Damma Belo..Devanagari Sign Anusvara + intArrayOf(0x0093a, 0x0093a), // Devanagari Vowel Sign Oe..Devanagari Vowel Sign Oe + intArrayOf(0x0093c, 0x0093c), // Devanagari Sign Nukta ..Devanagari Sign Nukta + intArrayOf(0x00941, 0x00948), // Devanagari Vowel Sign U ..Devanagari Vowel Sign Ai + intArrayOf(0x0094d, 0x0094d), // Devanagari Sign Virama ..Devanagari Sign Virama + intArrayOf(0x00951, 0x00957), // Devanagari Stress Sign U..Devanagari Vowel Sign Uu + intArrayOf(0x00962, 0x00963), // Devanagari Vowel Sign Vo..Devanagari Vowel Sign Vo + intArrayOf(0x00981, 0x00981), // Bengali Sign Candrabindu..Bengali Sign Candrabindu + intArrayOf(0x009bc, 0x009bc), // Bengali Sign Nukta ..Bengali Sign Nukta + intArrayOf(0x009c1, 0x009c4), // Bengali Vowel Sign U ..Bengali Vowel Sign Vocal + intArrayOf(0x009cd, 0x009cd), // Bengali Sign Virama ..Bengali Sign Virama + intArrayOf(0x009e2, 0x009e3), // Bengali Vowel Sign Vocal..Bengali Vowel Sign Vocal + intArrayOf(0x009fe, 0x009fe), // Bengali Sandhi Mark ..Bengali Sandhi Mark + intArrayOf(0x00a01, 0x00a02), // Gurmukhi Sign Adak Bindi..Gurmukhi Sign Bindi + intArrayOf(0x00a3c, 0x00a3c), // Gurmukhi Sign Nukta ..Gurmukhi Sign Nukta + intArrayOf(0x00a41, 0x00a42), // Gurmukhi Vowel Sign U ..Gurmukhi Vowel Sign Uu + intArrayOf(0x00a47, 0x00a48), // Gurmukhi Vowel Sign Ee ..Gurmukhi Vowel Sign Ai + intArrayOf(0x00a4b, 0x00a4d), // Gurmukhi Vowel Sign Oo ..Gurmukhi Sign Virama + intArrayOf(0x00a51, 0x00a51), // Gurmukhi Sign Udaat ..Gurmukhi Sign Udaat + intArrayOf(0x00a70, 0x00a71), // Gurmukhi Tippi ..Gurmukhi Addak + intArrayOf(0x00a75, 0x00a75), // Gurmukhi Sign Yakash ..Gurmukhi Sign Yakash + intArrayOf(0x00a81, 0x00a82), // Gujarati Sign Candrabind..Gujarati Sign Anusvara + intArrayOf(0x00abc, 0x00abc), // Gujarati Sign Nukta ..Gujarati Sign Nukta + intArrayOf(0x00ac1, 0x00ac5), // Gujarati Vowel Sign U ..Gujarati Vowel Sign Cand + intArrayOf(0x00ac7, 0x00ac8), // Gujarati Vowel Sign E ..Gujarati Vowel Sign Ai + intArrayOf(0x00acd, 0x00acd), // Gujarati Sign Virama ..Gujarati Sign Virama + intArrayOf(0x00ae2, 0x00ae3), // Gujarati Vowel Sign Voca..Gujarati Vowel Sign Voca + intArrayOf(0x00afa, 0x00aff), // Gujarati Sign Sukun ..Gujarati Sign Two-circle + intArrayOf(0x00b01, 0x00b01), // Oriya Sign Candrabindu ..Oriya Sign Candrabindu + intArrayOf(0x00b3c, 0x00b3c), // Oriya Sign Nukta ..Oriya Sign Nukta + intArrayOf(0x00b3f, 0x00b3f), // Oriya Vowel Sign I ..Oriya Vowel Sign I + intArrayOf(0x00b41, 0x00b44), // Oriya Vowel Sign U ..Oriya Vowel Sign Vocalic + intArrayOf(0x00b4d, 0x00b4d), // Oriya Sign Virama ..Oriya Sign Virama + intArrayOf(0x00b55, 0x00b56), // Oriya Sign Overline ..Oriya Ai Length Mark + intArrayOf(0x00b62, 0x00b63), // Oriya Vowel Sign Vocalic..Oriya Vowel Sign Vocalic + intArrayOf(0x00b82, 0x00b82), // Tamil Sign Anusvara ..Tamil Sign Anusvara + intArrayOf(0x00bc0, 0x00bc0), // Tamil Vowel Sign Ii ..Tamil Vowel Sign Ii + intArrayOf(0x00bcd, 0x00bcd), // Tamil Sign Virama ..Tamil Sign Virama + intArrayOf(0x00c00, 0x00c00), // Telugu Sign Combining Ca..Telugu Sign Combining Ca + intArrayOf(0x00c04, 0x00c04), // Telugu Sign Combining An..Telugu Sign Combining An + intArrayOf(0x00c3c, 0x00c3c), // Telugu Sign Nukta ..Telugu Sign Nukta + intArrayOf(0x00c3e, 0x00c40), // Telugu Vowel Sign Aa ..Telugu Vowel Sign Ii + intArrayOf(0x00c46, 0x00c48), // Telugu Vowel Sign E ..Telugu Vowel Sign Ai + intArrayOf(0x00c4a, 0x00c4d), // Telugu Vowel Sign O ..Telugu Sign Virama + intArrayOf(0x00c55, 0x00c56), // Telugu Length Mark ..Telugu Ai Length Mark + intArrayOf(0x00c62, 0x00c63), // Telugu Vowel Sign Vocali..Telugu Vowel Sign Vocali + intArrayOf(0x00c81, 0x00c81), // Kannada Sign Candrabindu..Kannada Sign Candrabindu + intArrayOf(0x00cbc, 0x00cbc), // Kannada Sign Nukta ..Kannada Sign Nukta + intArrayOf(0x00cbf, 0x00cbf), // Kannada Vowel Sign I ..Kannada Vowel Sign I + intArrayOf(0x00cc6, 0x00cc6), // Kannada Vowel Sign E ..Kannada Vowel Sign E + intArrayOf(0x00ccc, 0x00ccd), // Kannada Vowel Sign Au ..Kannada Sign Virama + intArrayOf(0x00ce2, 0x00ce3), // Kannada Vowel Sign Vocal..Kannada Vowel Sign Vocal + intArrayOf(0x00d00, 0x00d01), // Malayalam Sign Combining..Malayalam Sign Candrabin + intArrayOf(0x00d3b, 0x00d3c), // Malayalam Sign Vertical ..Malayalam Sign Circular + intArrayOf(0x00d41, 0x00d44), // Malayalam Vowel Sign U ..Malayalam Vowel Sign Voc + intArrayOf(0x00d4d, 0x00d4d), // Malayalam Sign Virama ..Malayalam Sign Virama + intArrayOf(0x00d62, 0x00d63), // Malayalam Vowel Sign Voc..Malayalam Vowel Sign Voc + intArrayOf(0x00d81, 0x00d81), // Sinhala Sign Candrabindu..Sinhala Sign Candrabindu + intArrayOf(0x00dca, 0x00dca), // Sinhala Sign Al-lakuna ..Sinhala Sign Al-lakuna + intArrayOf(0x00dd2, 0x00dd4), // Sinhala Vowel Sign Ketti..Sinhala Vowel Sign Ketti + intArrayOf(0x00dd6, 0x00dd6), // Sinhala Vowel Sign Diga ..Sinhala Vowel Sign Diga + intArrayOf(0x00e31, 0x00e31), // Thai Character Mai Han-a..Thai Character Mai Han-a + intArrayOf(0x00e34, 0x00e3a), // Thai Character Sara I ..Thai Character Phinthu + intArrayOf(0x00e47, 0x00e4e), // Thai Character Maitaikhu..Thai Character Yamakkan + intArrayOf(0x00eb1, 0x00eb1), // Lao Vowel Sign Mai Kan ..Lao Vowel Sign Mai Kan + intArrayOf(0x00eb4, 0x00ebc), // Lao Vowel Sign I ..Lao Semivowel Sign Lo + intArrayOf(0x00ec8, 0x00ece), // Lao Tone Mai Ek ..(nil) + intArrayOf(0x00f18, 0x00f19), // Tibetan Astrological Sig..Tibetan Astrological Sig + intArrayOf(0x00f35, 0x00f35), // Tibetan Mark Ngas Bzung ..Tibetan Mark Ngas Bzung + intArrayOf(0x00f37, 0x00f37), // Tibetan Mark Ngas Bzung ..Tibetan Mark Ngas Bzung + intArrayOf(0x00f39, 0x00f39), // Tibetan Mark Tsa -phru ..Tibetan Mark Tsa -phru + intArrayOf(0x00f71, 0x00f7e), // Tibetan Vowel Sign Aa ..Tibetan Sign Rjes Su Nga + intArrayOf(0x00f80, 0x00f84), // Tibetan Vowel Sign Rever..Tibetan Mark Halanta + intArrayOf(0x00f86, 0x00f87), // Tibetan Sign Lci Rtags ..Tibetan Sign Yang Rtags + intArrayOf(0x00f8d, 0x00f97), // Tibetan Subjoined Sign L..Tibetan Subjoined Letter + intArrayOf(0x00f99, 0x00fbc), // Tibetan Subjoined Letter..Tibetan Subjoined Letter + intArrayOf(0x00fc6, 0x00fc6), // Tibetan Symbol Padma Gda..Tibetan Symbol Padma Gda + intArrayOf(0x0102d, 0x01030), // Myanmar Vowel Sign I ..Myanmar Vowel Sign Uu + intArrayOf(0x01032, 0x01037), // Myanmar Vowel Sign Ai ..Myanmar Sign Dot Below + intArrayOf(0x01039, 0x0103a), // Myanmar Sign Virama ..Myanmar Sign Asat + intArrayOf(0x0103d, 0x0103e), // Myanmar Consonant Sign M..Myanmar Consonant Sign M + intArrayOf(0x01058, 0x01059), // Myanmar Vowel Sign Vocal..Myanmar Vowel Sign Vocal + intArrayOf(0x0105e, 0x01060), // Myanmar Consonant Sign M..Myanmar Consonant Sign M + intArrayOf(0x01071, 0x01074), // Myanmar Vowel Sign Geba ..Myanmar Vowel Sign Kayah + intArrayOf(0x01082, 0x01082), // Myanmar Consonant Sign S..Myanmar Consonant Sign S + intArrayOf(0x01085, 0x01086), // Myanmar Vowel Sign Shan ..Myanmar Vowel Sign Shan + intArrayOf(0x0108d, 0x0108d), // Myanmar Sign Shan Counci..Myanmar Sign Shan Counci + intArrayOf(0x0109d, 0x0109d), // Myanmar Vowel Sign Aiton..Myanmar Vowel Sign Aiton + intArrayOf(0x0135d, 0x0135f), // Ethiopic Combining Gemin..Ethiopic Combining Gemin + intArrayOf(0x01712, 0x01714), // Tagalog Vowel Sign I ..Tagalog Sign Virama + intArrayOf(0x01732, 0x01733), // Hanunoo Vowel Sign I ..Hanunoo Vowel Sign U + intArrayOf(0x01752, 0x01753), // Buhid Vowel Sign I ..Buhid Vowel Sign U + intArrayOf(0x01772, 0x01773), // Tagbanwa Vowel Sign I ..Tagbanwa Vowel Sign U + intArrayOf(0x017b4, 0x017b5), // Khmer Vowel Inherent Aq ..Khmer Vowel Inherent Aa + intArrayOf(0x017b7, 0x017bd), // Khmer Vowel Sign I ..Khmer Vowel Sign Ua + intArrayOf(0x017c6, 0x017c6), // Khmer Sign Nikahit ..Khmer Sign Nikahit + intArrayOf(0x017c9, 0x017d3), // Khmer Sign Muusikatoan ..Khmer Sign Bathamasat + intArrayOf(0x017dd, 0x017dd), // Khmer Sign Atthacan ..Khmer Sign Atthacan + intArrayOf(0x0180b, 0x0180d), // Mongolian Free Variation..Mongolian Free Variation + intArrayOf(0x0180f, 0x0180f), // Mongolian Free Variation..Mongolian Free Variation + intArrayOf(0x01885, 0x01886), // Mongolian Letter Ali Gal..Mongolian Letter Ali Gal + intArrayOf(0x018a9, 0x018a9), // Mongolian Letter Ali Gal..Mongolian Letter Ali Gal + intArrayOf(0x01920, 0x01922), // Limbu Vowel Sign A ..Limbu Vowel Sign U + intArrayOf(0x01927, 0x01928), // Limbu Vowel Sign E ..Limbu Vowel Sign O + intArrayOf(0x01932, 0x01932), // Limbu Small Letter Anusv..Limbu Small Letter Anusv + intArrayOf(0x01939, 0x0193b), // Limbu Sign Mukphreng ..Limbu Sign Sa-i + intArrayOf(0x01a17, 0x01a18), // Buginese Vowel Sign I ..Buginese Vowel Sign U + intArrayOf(0x01a1b, 0x01a1b), // Buginese Vowel Sign Ae ..Buginese Vowel Sign Ae + intArrayOf(0x01a56, 0x01a56), // Tai Tham Consonant Sign ..Tai Tham Consonant Sign + intArrayOf(0x01a58, 0x01a5e), // Tai Tham Sign Mai Kang L..Tai Tham Consonant Sign + intArrayOf(0x01a60, 0x01a60), // Tai Tham Sign Sakot ..Tai Tham Sign Sakot + intArrayOf(0x01a62, 0x01a62), // Tai Tham Vowel Sign Mai ..Tai Tham Vowel Sign Mai + intArrayOf(0x01a65, 0x01a6c), // Tai Tham Vowel Sign I ..Tai Tham Vowel Sign Oa B + intArrayOf(0x01a73, 0x01a7c), // Tai Tham Vowel Sign Oa A..Tai Tham Sign Khuen-lue + intArrayOf(0x01a7f, 0x01a7f), // Tai Tham Combining Crypt..Tai Tham Combining Crypt + intArrayOf(0x01ab0, 0x01ace), // Combining Doubled Circum..Combining Latin Small Le + intArrayOf(0x01b00, 0x01b03), // Balinese Sign Ulu Ricem ..Balinese Sign Surang + intArrayOf(0x01b34, 0x01b34), // Balinese Sign Rerekan ..Balinese Sign Rerekan + intArrayOf(0x01b36, 0x01b3a), // Balinese Vowel Sign Ulu ..Balinese Vowel Sign Ra R + intArrayOf(0x01b3c, 0x01b3c), // Balinese Vowel Sign La L..Balinese Vowel Sign La L + intArrayOf(0x01b42, 0x01b42), // Balinese Vowel Sign Pepe..Balinese Vowel Sign Pepe + intArrayOf(0x01b6b, 0x01b73), // Balinese Musical Symbol ..Balinese Musical Symbol + intArrayOf(0x01b80, 0x01b81), // Sundanese Sign Panyecek ..Sundanese Sign Panglayar + intArrayOf(0x01ba2, 0x01ba5), // Sundanese Consonant Sign..Sundanese Vowel Sign Pan + intArrayOf(0x01ba8, 0x01ba9), // Sundanese Vowel Sign Pam..Sundanese Vowel Sign Pan + intArrayOf(0x01bab, 0x01bad), // Sundanese Sign Virama ..Sundanese Consonant Sign + intArrayOf(0x01be6, 0x01be6), // Batak Sign Tompi ..Batak Sign Tompi + intArrayOf(0x01be8, 0x01be9), // Batak Vowel Sign Pakpak ..Batak Vowel Sign Ee + intArrayOf(0x01bed, 0x01bed), // Batak Vowel Sign Karo O ..Batak Vowel Sign Karo O + intArrayOf(0x01bef, 0x01bf1), // Batak Vowel Sign U For S..Batak Consonant Sign H + intArrayOf(0x01c2c, 0x01c33), // Lepcha Vowel Sign E ..Lepcha Consonant Sign T + intArrayOf(0x01c36, 0x01c37), // Lepcha Sign Ran ..Lepcha Sign Nukta + intArrayOf(0x01cd0, 0x01cd2), // Vedic Tone Karshana ..Vedic Tone Prenkha + intArrayOf(0x01cd4, 0x01ce0), // Vedic Sign Yajurvedic Mi..Vedic Tone Rigvedic Kash + intArrayOf(0x01ce2, 0x01ce8), // Vedic Sign Visarga Svari..Vedic Sign Visarga Anuda + intArrayOf(0x01ced, 0x01ced), // Vedic Sign Tiryak ..Vedic Sign Tiryak + intArrayOf(0x01cf4, 0x01cf4), // Vedic Tone Candra Above ..Vedic Tone Candra Above + intArrayOf(0x01cf8, 0x01cf9), // Vedic Tone Ring Above ..Vedic Tone Double Ring A + intArrayOf(0x01dc0, 0x01dff), // Combining Dotted Grave A..Combining Right Arrowhea + intArrayOf(0x020d0, 0x020f0), // Combining Left Harpoon A..Combining Asterisk Above + intArrayOf(0x02cef, 0x02cf1), // Coptic Combining Ni Abov..Coptic Combining Spiritu + intArrayOf(0x02d7f, 0x02d7f), // Tifinagh Consonant Joine..Tifinagh Consonant Joine + intArrayOf(0x02de0, 0x02dff), // Combining Cyrillic Lette..Combining Cyrillic Lette + intArrayOf(0x0302a, 0x0302d), // Ideographic Level Tone M..Ideographic Entering Ton + intArrayOf(0x03099, 0x0309a), // Combining Katakana-hirag..Combining Katakana-hirag + intArrayOf(0x0a66f, 0x0a672), // Combining Cyrillic Vzmet..Combining Cyrillic Thous + intArrayOf(0x0a674, 0x0a67d), // Combining Cyrillic Lette..Combining Cyrillic Payer + intArrayOf(0x0a69e, 0x0a69f), // Combining Cyrillic Lette..Combining Cyrillic Lette + intArrayOf(0x0a6f0, 0x0a6f1), // Bamum Combining Mark Koq..Bamum Combining Mark Tuk + intArrayOf(0x0a802, 0x0a802), // Syloti Nagri Sign Dvisva..Syloti Nagri Sign Dvisva + intArrayOf(0x0a806, 0x0a806), // Syloti Nagri Sign Hasant..Syloti Nagri Sign Hasant + intArrayOf(0x0a80b, 0x0a80b), // Syloti Nagri Sign Anusva..Syloti Nagri Sign Anusva + intArrayOf(0x0a825, 0x0a826), // Syloti Nagri Vowel Sign ..Syloti Nagri Vowel Sign + intArrayOf(0x0a82c, 0x0a82c), // Syloti Nagri Sign Altern..Syloti Nagri Sign Altern + intArrayOf(0x0a8c4, 0x0a8c5), // Saurashtra Sign Virama ..Saurashtra Sign Candrabi + intArrayOf(0x0a8e0, 0x0a8f1), // Combining Devanagari Dig..Combining Devanagari Sig + intArrayOf(0x0a8ff, 0x0a8ff), // Devanagari Vowel Sign Ay..Devanagari Vowel Sign Ay + intArrayOf(0x0a926, 0x0a92d), // Kayah Li Vowel Ue ..Kayah Li Tone Calya Plop + intArrayOf(0x0a947, 0x0a951), // Rejang Vowel Sign I ..Rejang Consonant Sign R + intArrayOf(0x0a980, 0x0a982), // Javanese Sign Panyangga ..Javanese Sign Layar + intArrayOf(0x0a9b3, 0x0a9b3), // Javanese Sign Cecak Telu..Javanese Sign Cecak Telu + intArrayOf(0x0a9b6, 0x0a9b9), // Javanese Vowel Sign Wulu..Javanese Vowel Sign Suku + intArrayOf(0x0a9bc, 0x0a9bd), // Javanese Vowel Sign Pepe..Javanese Consonant Sign + intArrayOf(0x0a9e5, 0x0a9e5), // Myanmar Sign Shan Saw ..Myanmar Sign Shan Saw + intArrayOf(0x0aa29, 0x0aa2e), // Cham Vowel Sign Aa ..Cham Vowel Sign Oe + intArrayOf(0x0aa31, 0x0aa32), // Cham Vowel Sign Au ..Cham Vowel Sign Ue + intArrayOf(0x0aa35, 0x0aa36), // Cham Consonant Sign La ..Cham Consonant Sign Wa + intArrayOf(0x0aa43, 0x0aa43), // Cham Consonant Sign Fina..Cham Consonant Sign Fina + intArrayOf(0x0aa4c, 0x0aa4c), // Cham Consonant Sign Fina..Cham Consonant Sign Fina + intArrayOf(0x0aa7c, 0x0aa7c), // Myanmar Sign Tai Laing T..Myanmar Sign Tai Laing T + intArrayOf(0x0aab0, 0x0aab0), // Tai Viet Mai Kang ..Tai Viet Mai Kang + intArrayOf(0x0aab2, 0x0aab4), // Tai Viet Vowel I ..Tai Viet Vowel U + intArrayOf(0x0aab7, 0x0aab8), // Tai Viet Mai Khit ..Tai Viet Vowel Ia + intArrayOf(0x0aabe, 0x0aabf), // Tai Viet Vowel Am ..Tai Viet Tone Mai Ek + intArrayOf(0x0aac1, 0x0aac1), // Tai Viet Tone Mai Tho ..Tai Viet Tone Mai Tho + intArrayOf(0x0aaec, 0x0aaed), // Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign + intArrayOf(0x0aaf6, 0x0aaf6), // Meetei Mayek Virama ..Meetei Mayek Virama + intArrayOf(0x0abe5, 0x0abe5), // Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign + intArrayOf(0x0abe8, 0x0abe8), // Meetei Mayek Vowel Sign ..Meetei Mayek Vowel Sign + intArrayOf(0x0abed, 0x0abed), // Meetei Mayek Apun Iyek ..Meetei Mayek Apun Iyek + intArrayOf(0x0fb1e, 0x0fb1e), // Hebrew Point Judeo-spani..Hebrew Point Judeo-spani + intArrayOf(0x0fe00, 0x0fe0f), // Variation Selector-1 ..Variation Selector-16 + intArrayOf(0x0fe20, 0x0fe2f), // Combining Ligature Left ..Combining Cyrillic Titlo + intArrayOf(0x101fd, 0x101fd), // Phaistos Disc Sign Combi..Phaistos Disc Sign Combi + intArrayOf(0x102e0, 0x102e0), // Coptic Epact Thousands M..Coptic Epact Thousands M + intArrayOf(0x10376, 0x1037a), // Combining Old Permic Let..Combining Old Permic Let + intArrayOf(0x10a01, 0x10a03), // Kharoshthi Vowel Sign I ..Kharoshthi Vowel Sign Vo + intArrayOf(0x10a05, 0x10a06), // Kharoshthi Vowel Sign E ..Kharoshthi Vowel Sign O + intArrayOf(0x10a0c, 0x10a0f), // Kharoshthi Vowel Length ..Kharoshthi Sign Visarga + intArrayOf(0x10a38, 0x10a3a), // Kharoshthi Sign Bar Abov..Kharoshthi Sign Dot Belo + intArrayOf(0x10a3f, 0x10a3f), // Kharoshthi Virama ..Kharoshthi Virama + intArrayOf(0x10ae5, 0x10ae6), // Manichaean Abbreviation ..Manichaean Abbreviation + intArrayOf(0x10d24, 0x10d27), // Hanifi Rohingya Sign Har..Hanifi Rohingya Sign Tas + intArrayOf(0x10eab, 0x10eac), // Yezidi Combining Hamza M..Yezidi Combining Madda M + intArrayOf(0x10efd, 0x10eff), // (nil) ..(nil) + intArrayOf(0x10f46, 0x10f50), // Sogdian Combining Dot Be..Sogdian Combining Stroke + intArrayOf(0x10f82, 0x10f85), // Old Uyghur Combining Dot..Old Uyghur Combining Two + intArrayOf(0x11001, 0x11001), // Brahmi Sign Anusvara ..Brahmi Sign Anusvara + intArrayOf(0x11038, 0x11046), // Brahmi Vowel Sign Aa ..Brahmi Virama + intArrayOf(0x11070, 0x11070), // Brahmi Sign Old Tamil Vi..Brahmi Sign Old Tamil Vi + intArrayOf(0x11073, 0x11074), // Brahmi Vowel Sign Old Ta..Brahmi Vowel Sign Old Ta + intArrayOf(0x1107f, 0x11081), // Brahmi Number Joiner ..Kaithi Sign Anusvara + intArrayOf(0x110b3, 0x110b6), // Kaithi Vowel Sign U ..Kaithi Vowel Sign Ai + intArrayOf(0x110b9, 0x110ba), // Kaithi Sign Virama ..Kaithi Sign Nukta + intArrayOf(0x110c2, 0x110c2), // Kaithi Vowel Sign Vocali..Kaithi Vowel Sign Vocali + intArrayOf(0x11100, 0x11102), // Chakma Sign Candrabindu ..Chakma Sign Visarga + intArrayOf(0x11127, 0x1112b), // Chakma Vowel Sign A ..Chakma Vowel Sign Uu + intArrayOf(0x1112d, 0x11134), // Chakma Vowel Sign Ai ..Chakma Maayyaa + intArrayOf(0x11173, 0x11173), // Mahajani Sign Nukta ..Mahajani Sign Nukta + intArrayOf(0x11180, 0x11181), // Sharada Sign Candrabindu..Sharada Sign Anusvara + intArrayOf(0x111b6, 0x111be), // Sharada Vowel Sign U ..Sharada Vowel Sign O + intArrayOf(0x111c9, 0x111cc), // Sharada Sandhi Mark ..Sharada Extra Short Vowe + intArrayOf(0x111cf, 0x111cf), // Sharada Sign Inverted Ca..Sharada Sign Inverted Ca + intArrayOf(0x1122f, 0x11231), // Khojki Vowel Sign U ..Khojki Vowel Sign Ai + intArrayOf(0x11234, 0x11234), // Khojki Sign Anusvara ..Khojki Sign Anusvara + intArrayOf(0x11236, 0x11237), // Khojki Sign Nukta ..Khojki Sign Shadda + intArrayOf(0x1123e, 0x1123e), // Khojki Sign Sukun ..Khojki Sign Sukun + intArrayOf(0x11241, 0x11241), // (nil) ..(nil) + intArrayOf(0x112df, 0x112df), // Khudawadi Sign Anusvara ..Khudawadi Sign Anusvara + intArrayOf(0x112e3, 0x112ea), // Khudawadi Vowel Sign U ..Khudawadi Sign Virama + intArrayOf(0x11300, 0x11301), // Grantha Sign Combining A..Grantha Sign Candrabindu + intArrayOf(0x1133b, 0x1133c), // Combining Bindu Below ..Grantha Sign Nukta + intArrayOf(0x11340, 0x11340), // Grantha Vowel Sign Ii ..Grantha Vowel Sign Ii + intArrayOf(0x11366, 0x1136c), // Combining Grantha Digit ..Combining Grantha Digit + intArrayOf(0x11370, 0x11374), // Combining Grantha Letter..Combining Grantha Letter + intArrayOf(0x11438, 0x1143f), // Newa Vowel Sign U ..Newa Vowel Sign Ai + intArrayOf(0x11442, 0x11444), // Newa Sign Virama ..Newa Sign Anusvara + intArrayOf(0x11446, 0x11446), // Newa Sign Nukta ..Newa Sign Nukta + intArrayOf(0x1145e, 0x1145e), // Newa Sandhi Mark ..Newa Sandhi Mark + intArrayOf(0x114b3, 0x114b8), // Tirhuta Vowel Sign U ..Tirhuta Vowel Sign Vocal + intArrayOf(0x114ba, 0x114ba), // Tirhuta Vowel Sign Short..Tirhuta Vowel Sign Short + intArrayOf(0x114bf, 0x114c0), // Tirhuta Sign Candrabindu..Tirhuta Sign Anusvara + intArrayOf(0x114c2, 0x114c3), // Tirhuta Sign Virama ..Tirhuta Sign Nukta + intArrayOf(0x115b2, 0x115b5), // Siddham Vowel Sign U ..Siddham Vowel Sign Vocal + intArrayOf(0x115bc, 0x115bd), // Siddham Sign Candrabindu..Siddham Sign Anusvara + intArrayOf(0x115bf, 0x115c0), // Siddham Sign Virama ..Siddham Sign Nukta + intArrayOf(0x115dc, 0x115dd), // Siddham Vowel Sign Alter..Siddham Vowel Sign Alter + intArrayOf(0x11633, 0x1163a), // Modi Vowel Sign U ..Modi Vowel Sign Ai + intArrayOf(0x1163d, 0x1163d), // Modi Sign Anusvara ..Modi Sign Anusvara + intArrayOf(0x1163f, 0x11640), // Modi Sign Virama ..Modi Sign Ardhacandra + intArrayOf(0x116ab, 0x116ab), // Takri Sign Anusvara ..Takri Sign Anusvara + intArrayOf(0x116ad, 0x116ad), // Takri Vowel Sign Aa ..Takri Vowel Sign Aa + intArrayOf(0x116b0, 0x116b5), // Takri Vowel Sign U ..Takri Vowel Sign Au + intArrayOf(0x116b7, 0x116b7), // Takri Sign Nukta ..Takri Sign Nukta + intArrayOf(0x1171d, 0x1171f), // Ahom Consonant Sign Medi..Ahom Consonant Sign Medi + intArrayOf(0x11722, 0x11725), // Ahom Vowel Sign I ..Ahom Vowel Sign Uu + intArrayOf(0x11727, 0x1172b), // Ahom Vowel Sign Aw ..Ahom Sign Killer + intArrayOf(0x1182f, 0x11837), // Dogra Vowel Sign U ..Dogra Sign Anusvara + intArrayOf(0x11839, 0x1183a), // Dogra Sign Virama ..Dogra Sign Nukta + intArrayOf(0x1193b, 0x1193c), // Dives Akuru Sign Anusvar..Dives Akuru Sign Candrab + intArrayOf(0x1193e, 0x1193e), // Dives Akuru Virama ..Dives Akuru Virama + intArrayOf(0x11943, 0x11943), // Dives Akuru Sign Nukta ..Dives Akuru Sign Nukta + intArrayOf(0x119d4, 0x119d7), // Nandinagari Vowel Sign U..Nandinagari Vowel Sign V + intArrayOf(0x119da, 0x119db), // Nandinagari Vowel Sign E..Nandinagari Vowel Sign A + intArrayOf(0x119e0, 0x119e0), // Nandinagari Sign Virama ..Nandinagari Sign Virama + intArrayOf(0x11a01, 0x11a0a), // Zanabazar Square Vowel S..Zanabazar Square Vowel L + intArrayOf(0x11a33, 0x11a38), // Zanabazar Square Final C..Zanabazar Square Sign An + intArrayOf(0x11a3b, 0x11a3e), // Zanabazar Square Cluster..Zanabazar Square Cluster + intArrayOf(0x11a47, 0x11a47), // Zanabazar Square Subjoin..Zanabazar Square Subjoin + intArrayOf(0x11a51, 0x11a56), // Soyombo Vowel Sign I ..Soyombo Vowel Sign Oe + intArrayOf(0x11a59, 0x11a5b), // Soyombo Vowel Sign Vocal..Soyombo Vowel Length Mar + intArrayOf(0x11a8a, 0x11a96), // Soyombo Final Consonant ..Soyombo Sign Anusvara + intArrayOf(0x11a98, 0x11a99), // Soyombo Gemination Mark ..Soyombo Subjoiner + intArrayOf(0x11c30, 0x11c36), // Bhaiksuki Vowel Sign I ..Bhaiksuki Vowel Sign Voc + intArrayOf(0x11c38, 0x11c3d), // Bhaiksuki Vowel Sign E ..Bhaiksuki Sign Anusvara + intArrayOf(0x11c3f, 0x11c3f), // Bhaiksuki Sign Virama ..Bhaiksuki Sign Virama + intArrayOf(0x11c92, 0x11ca7), // Marchen Subjoined Letter..Marchen Subjoined Letter + intArrayOf(0x11caa, 0x11cb0), // Marchen Subjoined Letter..Marchen Vowel Sign Aa + intArrayOf(0x11cb2, 0x11cb3), // Marchen Vowel Sign U ..Marchen Vowel Sign E + intArrayOf(0x11cb5, 0x11cb6), // Marchen Sign Anusvara ..Marchen Sign Candrabindu + intArrayOf(0x11d31, 0x11d36), // Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign + intArrayOf(0x11d3a, 0x11d3a), // Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign + intArrayOf(0x11d3c, 0x11d3d), // Masaram Gondi Vowel Sign..Masaram Gondi Vowel Sign + intArrayOf(0x11d3f, 0x11d45), // Masaram Gondi Vowel Sign..Masaram Gondi Virama + intArrayOf(0x11d47, 0x11d47), // Masaram Gondi Ra-kara ..Masaram Gondi Ra-kara + intArrayOf(0x11d90, 0x11d91), // Gunjala Gondi Vowel Sign..Gunjala Gondi Vowel Sign + intArrayOf(0x11d95, 0x11d95), // Gunjala Gondi Sign Anusv..Gunjala Gondi Sign Anusv + intArrayOf(0x11d97, 0x11d97), // Gunjala Gondi Virama ..Gunjala Gondi Virama + intArrayOf(0x11ef3, 0x11ef4), // Makasar Vowel Sign I ..Makasar Vowel Sign U + intArrayOf(0x11f00, 0x11f01), // (nil) ..(nil) + intArrayOf(0x11f36, 0x11f3a), // (nil) ..(nil) + intArrayOf(0x11f40, 0x11f40), // (nil) ..(nil) + intArrayOf(0x11f42, 0x11f42), // (nil) ..(nil) + intArrayOf(0x13440, 0x13440), // (nil) ..(nil) + intArrayOf(0x13447, 0x13455), // (nil) ..(nil) + intArrayOf(0x16af0, 0x16af4), // Bassa Vah Combining High..Bassa Vah Combining High + intArrayOf(0x16b30, 0x16b36), // Pahawh Hmong Mark Cim Tu..Pahawh Hmong Mark Cim Ta + intArrayOf(0x16f4f, 0x16f4f), // Miao Sign Consonant Modi..Miao Sign Consonant Modi + intArrayOf(0x16f8f, 0x16f92), // Miao Tone Right ..Miao Tone Below + intArrayOf(0x16fe4, 0x16fe4), // Khitan Small Script Fill..Khitan Small Script Fill + intArrayOf(0x1bc9d, 0x1bc9e), // Duployan Thick Letter Se..Duployan Double Mark + intArrayOf(0x1cf00, 0x1cf2d), // Znamenny Combining Mark ..Znamenny Combining Mark + intArrayOf(0x1cf30, 0x1cf46), // Znamenny Combining Tonal..Znamenny Priznak Modifie + intArrayOf(0x1d167, 0x1d169), // Musical Symbol Combining..Musical Symbol Combining + intArrayOf(0x1d17b, 0x1d182), // Musical Symbol Combining..Musical Symbol Combining + intArrayOf(0x1d185, 0x1d18b), // Musical Symbol Combining..Musical Symbol Combining + intArrayOf(0x1d1aa, 0x1d1ad), // Musical Symbol Combining..Musical Symbol Combining + intArrayOf(0x1d242, 0x1d244), // Combining Greek Musical ..Combining Greek Musical + intArrayOf(0x1da00, 0x1da36), // Signwriting Head Rim ..Signwriting Air Sucking + intArrayOf(0x1da3b, 0x1da6c), // Signwriting Mouth Closed..Signwriting Excitement + intArrayOf(0x1da75, 0x1da75), // Signwriting Upper Body T..Signwriting Upper Body T + intArrayOf(0x1da84, 0x1da84), // Signwriting Location Hea..Signwriting Location Hea + intArrayOf(0x1da9b, 0x1da9f), // Signwriting Fill Modifie..Signwriting Fill Modifie + intArrayOf(0x1daa1, 0x1daaf), // Signwriting Rotation Mod..Signwriting Rotation Mod + intArrayOf(0x1e000, 0x1e006), // Combining Glagolitic Let..Combining Glagolitic Let + intArrayOf(0x1e008, 0x1e018), // Combining Glagolitic Let..Combining Glagolitic Let + intArrayOf(0x1e01b, 0x1e021), // Combining Glagolitic Let..Combining Glagolitic Let + intArrayOf(0x1e023, 0x1e024), // Combining Glagolitic Let..Combining Glagolitic Let + intArrayOf(0x1e026, 0x1e02a), // Combining Glagolitic Let..Combining Glagolitic Let + intArrayOf(0x1e08f, 0x1e08f), // (nil) ..(nil) + intArrayOf(0x1e130, 0x1e136), // Nyiakeng Puachue Hmong T..Nyiakeng Puachue Hmong T + intArrayOf(0x1e2ae, 0x1e2ae), // Toto Sign Rising Tone ..Toto Sign Rising Tone + intArrayOf(0x1e2ec, 0x1e2ef), // Wancho Tone Tup ..Wancho Tone Koini + intArrayOf(0x1e4ec, 0x1e4ef), // (nil) ..(nil) + intArrayOf(0x1e8d0, 0x1e8d6), // Mende Kikakui Combining ..Mende Kikakui Combining + intArrayOf(0x1e944, 0x1e94a), // Adlam Alif Lengthener ..Adlam Nukta + intArrayOf(0xe0100, 0xe01ef), // Variation Selector-17 ..Variation Selector-256 + ) + + // https://github.com/jquast/wcwidth/blob/master/wcwidth/table_wide.py + // from https://github.com/jquast/wcwidth/pull/64 + // at commit 1b9b6585b0080ea5cb88dc9815796505724793fe (2022-12-16): + private val WIDE_EASTASIAN = arrayOf( + intArrayOf(0x01100, 0x0115f), // Hangul Choseong Kiyeok ..Hangul Choseong Filler + intArrayOf(0x0231a, 0x0231b), // Watch ..Hourglass + intArrayOf(0x02329, 0x0232a), // Left-pointing Angle Brac..Right-pointing Angle Bra + intArrayOf(0x023e9, 0x023ec), // Black Right-pointing Dou..Black Down-pointing Doub + intArrayOf(0x023f0, 0x023f0), // Alarm Clock ..Alarm Clock + intArrayOf(0x023f3, 0x023f3), // Hourglass With Flowing S..Hourglass With Flowing S + intArrayOf(0x025fd, 0x025fe), // White Medium Small Squar..Black Medium Small Squar + intArrayOf(0x02614, 0x02615), // Umbrella With Rain Drops..Hot Beverage + intArrayOf(0x02648, 0x02653), // Aries ..Pisces + intArrayOf(0x0267f, 0x0267f), // Wheelchair Symbol ..Wheelchair Symbol + intArrayOf(0x02693, 0x02693), // Anchor ..Anchor + intArrayOf(0x026a1, 0x026a1), // High Voltage Sign ..High Voltage Sign + intArrayOf(0x026aa, 0x026ab), // Medium White Circle ..Medium Black Circle + intArrayOf(0x026bd, 0x026be), // Soccer Ball ..Baseball + intArrayOf(0x026c4, 0x026c5), // Snowman Without Snow ..Sun Behind Cloud + intArrayOf(0x026ce, 0x026ce), // Ophiuchus ..Ophiuchus + intArrayOf(0x026d4, 0x026d4), // No Entry ..No Entry + intArrayOf(0x026ea, 0x026ea), // Church ..Church + intArrayOf(0x026f2, 0x026f3), // Fountain ..Flag In Hole + intArrayOf(0x026f5, 0x026f5), // Sailboat ..Sailboat + intArrayOf(0x026fa, 0x026fa), // Tent ..Tent + intArrayOf(0x026fd, 0x026fd), // Fuel Pump ..Fuel Pump + intArrayOf(0x02705, 0x02705), // White Heavy Check Mark ..White Heavy Check Mark + intArrayOf(0x0270a, 0x0270b), // Raised Fist ..Raised Hand + intArrayOf(0x02728, 0x02728), // Sparkles ..Sparkles + intArrayOf(0x0274c, 0x0274c), // Cross Mark ..Cross Mark + intArrayOf(0x0274e, 0x0274e), // Negative Squared Cross M..Negative Squared Cross M + intArrayOf(0x02753, 0x02755), // Black Question Mark Orna..White Exclamation Mark O + intArrayOf(0x02757, 0x02757), // Heavy Exclamation Mark S..Heavy Exclamation Mark S + intArrayOf(0x02795, 0x02797), // Heavy Plus Sign ..Heavy Division Sign + intArrayOf(0x027b0, 0x027b0), // Curly Loop ..Curly Loop + intArrayOf(0x027bf, 0x027bf), // Double Curly Loop ..Double Curly Loop + intArrayOf(0x02b1b, 0x02b1c), // Black Large Square ..White Large Square + intArrayOf(0x02b50, 0x02b50), // White Medium Star ..White Medium Star + intArrayOf(0x02b55, 0x02b55), // Heavy Large Circle ..Heavy Large Circle + intArrayOf(0x02e80, 0x02e99), // Cjk Radical Repeat ..Cjk Radical Rap + intArrayOf(0x02e9b, 0x02ef3), // Cjk Radical Choke ..Cjk Radical C-simplified + intArrayOf(0x02f00, 0x02fd5), // Kangxi Radical One ..Kangxi Radical Flute + intArrayOf(0x02ff0, 0x02ffb), // Ideographic Description ..Ideographic Description + intArrayOf(0x03000, 0x0303e), // Ideographic Space ..Ideographic Variation In + intArrayOf(0x03041, 0x03096), // Hiragana Letter Small A ..Hiragana Letter Small Ke + intArrayOf(0x03099, 0x030ff), // Combining Katakana-hirag..Katakana Digraph Koto + intArrayOf(0x03105, 0x0312f), // Bopomofo Letter B ..Bopomofo Letter Nn + intArrayOf(0x03131, 0x0318e), // Hangul Letter Kiyeok ..Hangul Letter Araeae + intArrayOf(0x03190, 0x031e3), // Ideographic Annotation L..Cjk Stroke Q + intArrayOf(0x031f0, 0x0321e), // Katakana Letter Small Ku..Parenthesized Korean Cha + intArrayOf(0x03220, 0x03247), // Parenthesized Ideograph ..Circled Ideograph Koto + intArrayOf(0x03250, 0x04dbf), // Partnership Sign ..Cjk Unified Ideograph-4d + intArrayOf(0x04e00, 0x0a48c), // Cjk Unified Ideograph-4e..Yi Syllable Yyr + intArrayOf(0x0a490, 0x0a4c6), // Yi Radical Qot ..Yi Radical Ke + intArrayOf(0x0a960, 0x0a97c), // Hangul Choseong Tikeut-m..Hangul Choseong Ssangyeo + intArrayOf(0x0ac00, 0x0d7a3), // Hangul Syllable Ga ..Hangul Syllable Hih + intArrayOf(0x0f900, 0x0faff), // Cjk Compatibility Ideogr..(nil) + intArrayOf(0x0fe10, 0x0fe19), // Presentation Form For Ve..Presentation Form For Ve + intArrayOf(0x0fe30, 0x0fe52), // Presentation Form For Ve..Small Full Stop + intArrayOf(0x0fe54, 0x0fe66), // Small Semicolon ..Small Equals Sign + intArrayOf(0x0fe68, 0x0fe6b), // Small Reverse Solidus ..Small Commercial At + intArrayOf(0x0ff01, 0x0ff60), // Fullwidth Exclamation Ma..Fullwidth Right White Pa + intArrayOf(0x0ffe0, 0x0ffe6), // Fullwidth Cent Sign ..Fullwidth Won Sign + intArrayOf(0x16fe0, 0x16fe4), // Tangut Iteration Mark ..Khitan Small Script Fill + intArrayOf(0x16ff0, 0x16ff1), // Vietnamese Alternate Rea..Vietnamese Alternate Rea + intArrayOf(0x17000, 0x187f7), // (nil) ..(nil) + intArrayOf(0x18800, 0x18cd5), // Tangut Component-001 ..Khitan Small Script Char + intArrayOf(0x18d00, 0x18d08), // (nil) ..(nil) + intArrayOf(0x1aff0, 0x1aff3), // Katakana Letter Minnan T..Katakana Letter Minnan T + intArrayOf(0x1aff5, 0x1affb), // Katakana Letter Minnan T..Katakana Letter Minnan N + intArrayOf(0x1affd, 0x1affe), // Katakana Letter Minnan N..Katakana Letter Minnan N + intArrayOf(0x1b000, 0x1b122), // Katakana Letter Archaic ..Katakana Letter Archaic + intArrayOf(0x1b132, 0x1b132), // (nil) ..(nil) + intArrayOf(0x1b150, 0x1b152), // Hiragana Letter Small Wi..Hiragana Letter Small Wo + intArrayOf(0x1b155, 0x1b155), // (nil) ..(nil) + intArrayOf(0x1b164, 0x1b167), // Katakana Letter Small Wi..Katakana Letter Small N + intArrayOf(0x1b170, 0x1b2fb), // Nushu Character-1b170 ..Nushu Character-1b2fb + intArrayOf(0x1f004, 0x1f004), // Mahjong Tile Red Dragon ..Mahjong Tile Red Dragon + intArrayOf(0x1f0cf, 0x1f0cf), // Playing Card Black Joker..Playing Card Black Joker + intArrayOf(0x1f18e, 0x1f18e), // Negative Squared Ab ..Negative Squared Ab + intArrayOf(0x1f191, 0x1f19a), // Squared Cl ..Squared Vs + intArrayOf(0x1f200, 0x1f202), // Square Hiragana Hoka ..Squared Katakana Sa + intArrayOf(0x1f210, 0x1f23b), // Squared Cjk Unified Ideo..Squared Cjk Unified Ideo + intArrayOf(0x1f240, 0x1f248), // Tortoise Shell Bracketed..Tortoise Shell Bracketed + intArrayOf(0x1f250, 0x1f251), // Circled Ideograph Advant..Circled Ideograph Accept + intArrayOf(0x1f260, 0x1f265), // Rounded Symbol For Fu ..Rounded Symbol For Cai + intArrayOf(0x1f300, 0x1f320), // Cyclone ..Shooting Star + intArrayOf(0x1f32d, 0x1f335), // Hot Dog ..Cactus + intArrayOf(0x1f337, 0x1f37c), // Tulip ..Baby Bottle + intArrayOf(0x1f37e, 0x1f393), // Bottle With Popping Cork..Graduation Cap + intArrayOf(0x1f3a0, 0x1f3ca), // Carousel Horse ..Swimmer + intArrayOf(0x1f3cf, 0x1f3d3), // Cricket Bat And Ball ..Table Tennis Paddle And + intArrayOf(0x1f3e0, 0x1f3f0), // House Building ..European Castle + intArrayOf(0x1f3f4, 0x1f3f4), // Waving Black Flag ..Waving Black Flag + intArrayOf(0x1f3f8, 0x1f43e), // Badminton Racquet And Sh..Paw Prints + intArrayOf(0x1f440, 0x1f440), // Eyes ..Eyes + intArrayOf(0x1f442, 0x1f4fc), // Ear ..Videocassette + intArrayOf(0x1f4ff, 0x1f53d), // Prayer Beads ..Down-pointing Small Red + intArrayOf(0x1f54b, 0x1f54e), // Kaaba ..Menorah With Nine Branch + intArrayOf(0x1f550, 0x1f567), // Clock Face One Oclock ..Clock Face Twelve-thirty + intArrayOf(0x1f57a, 0x1f57a), // Man Dancing ..Man Dancing + intArrayOf(0x1f595, 0x1f596), // Reversed Hand With Middl..Raised Hand With Part Be + intArrayOf(0x1f5a4, 0x1f5a4), // Black Heart ..Black Heart + intArrayOf(0x1f5fb, 0x1f64f), // Mount Fuji ..Person With Folded Hands + intArrayOf(0x1f680, 0x1f6c5), // Rocket ..Left Luggage + intArrayOf(0x1f6cc, 0x1f6cc), // Sleeping Accommodation ..Sleeping Accommodation + intArrayOf(0x1f6d0, 0x1f6d2), // Place Of Worship ..Shopping Trolley + intArrayOf(0x1f6d5, 0x1f6d7), // Hindu Temple ..Elevator + intArrayOf(0x1f6dc, 0x1f6df), // (nil) ..Ring Buoy + intArrayOf(0x1f6eb, 0x1f6ec), // Airplane Departure ..Airplane Arriving + intArrayOf(0x1f6f4, 0x1f6fc), // Scooter ..Roller Skate + intArrayOf(0x1f7e0, 0x1f7eb), // Large Orange Circle ..Large Brown Square + intArrayOf(0x1f7f0, 0x1f7f0), // Heavy Equals Sign ..Heavy Equals Sign + intArrayOf(0x1f90c, 0x1f93a), // Pinched Fingers ..Fencer + intArrayOf(0x1f93c, 0x1f945), // Wrestlers ..Goal Net + intArrayOf(0x1f947, 0x1f9ff), // First Place Medal ..Nazar Amulet + intArrayOf(0x1fa70, 0x1fa7c), // Ballet Shoes ..Crutch + intArrayOf(0x1fa80, 0x1fa88), // Yo-yo ..(nil) + intArrayOf(0x1fa90, 0x1fabd), // Ringed Planet ..(nil) + intArrayOf(0x1fabf, 0x1fac5), // (nil) ..Person With Crown + intArrayOf(0x1face, 0x1fadb), // (nil) ..(nil) + intArrayOf(0x1fae0, 0x1fae8), // Melting Face ..(nil) + intArrayOf(0x1faf0, 0x1faf8), // Hand With Index Finger A..(nil) + intArrayOf(0x20000, 0x2fffd), // Cjk Unified Ideograph-20..(nil) + intArrayOf(0x30000, 0x3fffd), // Cjk Unified Ideograph-30..(nil) + ) + + private fun intable(table: Array, c: Int): Boolean { + if (c < table[0][0]) return false + var bot = 0 + var top = table.size - 1 + while (top >= bot) { + val mid = (bot + top) / 2 + if (table[mid][1] < c) { + bot = mid + 1 + } else if (table[mid][0] > c) { + top = mid - 1 + } else { + return true + } + } + return false + } + + /** Return the terminal display width of a code point: 0, 1 or 2. */ + fun width(ucs: Int): Int { + if (ucs == 0 || + ucs == 0x034F || + (ucs in 0x200B..0x200F) || + ucs == 0x2028 || + ucs == 0x2029 || + (ucs in 0x202A..0x202E) || + (ucs in 0x2060..0x2063)) { + return 0 + } + + // C0/C1 control characters + // Termux change: Return 0 instead of -1. + if (ucs < 32 || (ucs in 0x07F until 0x0A0)) return 0 + + if (intable(ZERO_WIDTH, ucs)) return 0 + + return if (intable(WIDE_EASTASIAN, ucs)) 2 else 1 + } + + /** The width at an index position in a java char array. */ + fun width(chars: CharArray, index: Int): Int { + val c = chars[index] + return if (Character.isHighSurrogate(c)) width(Character.toCodePoint(c, chars[index + 1])) else width(c.code) + } + + /** + * The zero width characters count like combining characters in the `chars` array from start + * index to end index (exclusive). + */ + fun zeroWidthCharsCount(chars: CharArray, start: Int, end: Int): Int { + if (start < 0 || start >= chars.size) return 0 + var count = 0 + var i = start + while (i < end && i < chars.size) { + if (Character.isHighSurrogate(chars[i])) { + if (width(Character.toCodePoint(chars[i], chars[i + 1])) <= 0) { + count++ + } + i += 2 + } else { + if (width(chars[i].code) <= 0) { + count++ + } + i++ + } + } + return count + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/MainActivity.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/MainActivity.kt new file mode 100644 index 000000000..1f947777f --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/MainActivity.kt @@ -0,0 +1,362 @@ +package com.topjohnwu.magisk.ui + +import android.Manifest +import android.Manifest.permission.REQUEST_INSTALL_PACKAGES +import android.annotation.SuppressLint +import android.content.Context +import android.content.Intent +import android.content.pm.ApplicationInfo +import android.content.res.Resources +import android.graphics.Color +import android.net.Uri +import android.os.Build +import android.os.Bundle +import android.view.WindowManager +import android.widget.Toast +import androidx.activity.compose.setContent +import androidx.appcompat.app.AppCompatActivity +import androidx.appcompat.app.AppCompatDelegate +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.ui.Modifier +import androidx.core.content.pm.ShortcutManagerCompat +import androidx.core.content.res.use +import androidx.core.view.WindowCompat +import androidx.lifecycle.lifecycleScope +import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator +import androidx.navigation3.runtime.entryProvider +import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator +import androidx.navigation3.ui.NavDisplay +import com.topjohnwu.magisk.arch.VMFactory +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.base.ActivityExtension +import com.topjohnwu.magisk.core.base.SplashController +import com.topjohnwu.magisk.core.base.SplashScreenHost +import com.topjohnwu.magisk.core.isRunningAsStub +import com.topjohnwu.magisk.core.ktx.reflectField +import com.topjohnwu.magisk.core.ktx.toast +import com.topjohnwu.magisk.core.tasks.AppMigration +import com.topjohnwu.magisk.core.wrap +import com.topjohnwu.magisk.ui.deny.DenyListScreen +import com.topjohnwu.magisk.ui.deny.DenyListViewModel +import com.topjohnwu.magisk.ui.flash.FlashScreen +import com.topjohnwu.magisk.ui.flash.FlashUtils +import com.topjohnwu.magisk.ui.flash.FlashViewModel +import com.topjohnwu.magisk.ui.module.ActionScreen +import com.topjohnwu.magisk.ui.module.ActionViewModel +import com.topjohnwu.magisk.ui.navigation.LocalNavigator +import com.topjohnwu.magisk.ui.navigation.Navigator +import com.topjohnwu.magisk.ui.navigation.Route +import com.topjohnwu.magisk.ui.navigation.rememberNavigator +import com.topjohnwu.magisk.ui.superuser.SuperuserDetailScreen +import com.topjohnwu.magisk.ui.superuser.SuperuserViewModel +import com.topjohnwu.magisk.ui.theme.MagiskTheme +import com.topjohnwu.magisk.ui.theme.Theme +import com.topjohnwu.magisk.view.Shortcuts +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.launch +import top.yukonga.miuix.kmp.utils.MiuixPopupUtils.Companion.MiuixPopupHost +import com.topjohnwu.magisk.core.R as CoreR + +class MainActivity : AppCompatActivity(), SplashScreenHost { + + override val extension = ActivityExtension(this) + override val splashController = SplashController(this) + + private val intentState = MutableStateFlow(0) + internal val showInvalidState = MutableStateFlow(false) + internal val showUnsupported = MutableStateFlow>>(emptyList()) + internal val showShortcutPrompt = MutableStateFlow(false) + + init { + AppCompatDelegate.setDefaultNightMode(Config.darkTheme) + } + + override fun attachBaseContext(base: Context) { + super.attachBaseContext(base.wrap()) + } + + override fun onCreate(savedInstanceState: Bundle?) { + extension.onCreate(savedInstanceState) + if (isRunningAsStub) { + val delegate = delegate + val clz = delegate.javaClass + clz.reflectField("mActivityHandlesConfigFlagsChecked").set(delegate, true) + clz.reflectField("mActivityHandlesConfigFlags").set(delegate, 0) + } + + setTheme(Theme.selected.themeRes) + splashController.preOnCreate() + super.onCreate(savedInstanceState) + splashController.onCreate(savedInstanceState) + + setupWindow() + } + + override fun onResume() { + super.onResume() + splashController.onResume() + } + + override fun onSaveInstanceState(outState: Bundle) { + super.onSaveInstanceState(outState) + extension.onSaveInstanceState(outState) + } + + private fun setupWindow() { + obtainStyledAttributes(intArrayOf(android.R.attr.windowBackground)) + .use { it.getDrawable(0) } + .also { window.setBackgroundDrawable(it) } + + WindowCompat.setDecorFitsSystemWindows(window, false) + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + window?.decorView?.post { + if ((window.decorView.rootWindowInsets?.systemWindowInsetBottom + ?: 0) < Resources.getSystem().displayMetrics.density * 40) { + window.navigationBarColor = Color.TRANSPARENT + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { + window.navigationBarDividerColor = Color.TRANSPARENT + } + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { + window.isNavigationBarContrastEnforced = false + window.isStatusBarContrastEnforced = false + } + } + } + } + } + + @SuppressLint("InlinedApi") + override fun onCreateUi(savedInstanceState: Bundle?) { + showUnsupportedMessage() + askForHomeShortcut() + + if (Config.checkUpdate) { + extension.withPermission(Manifest.permission.POST_NOTIFICATIONS) { + Config.checkUpdate = it + } + } + + window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE) + + val initialTab = getInitialTab(intent) + + setContent { + MagiskTheme { + Box(modifier = Modifier.fillMaxSize()) { + val navigator = rememberNavigator(Route.Main) + CompositionLocalProvider(LocalNavigator provides navigator) { + HandleFlashIntent(navigator) + + NavDisplay( + backStack = navigator.backStack, + onBack = { navigator.pop() }, + entryDecorators = listOf( + rememberSaveableStateHolderNavEntryDecorator(), + rememberViewModelStoreNavEntryDecorator() + ), + entryProvider = entryProvider { + entry { + MainScreen(initialTab = initialTab) + } + entry { _ -> + val vm: DenyListViewModel = androidx.lifecycle.viewmodel.compose.viewModel(factory = VMFactory) + LaunchedEffect(Unit) { vm.startLoading() } + DenyListScreen(vm, onBack = { navigator.pop() }) + } + entry { key -> + val vm: FlashViewModel = androidx.lifecycle.viewmodel.compose.viewModel(factory = VMFactory) + LaunchedEffect(key) { + if (vm.flashAction.isEmpty()) { + vm.flashAction = key.action + vm.flashUri = key.additionalData?.let { Uri.parse(it) } + vm.startFlashing() + } + } + FlashScreen(vm, action = key.action, onBack = { navigator.pop() }) + } + entry { key -> + val vm: SuperuserViewModel = androidx.lifecycle.viewmodel.compose.viewModel( + viewModelStoreOwner = this@MainActivity, factory = VMFactory + ) + LaunchedEffect(Unit) { + vm.authenticate = { onSuccess -> + extension.withAuthentication { if (it) onSuccess() } + } + } + SuperuserDetailScreen(uid = key.uid, viewModel = vm, onBack = { navigator.pop() }) + } + entry { key -> + val vm: ActionViewModel = androidx.lifecycle.viewmodel.compose.viewModel(factory = VMFactory) + LaunchedEffect(key) { + if (vm.actionId.isEmpty()) { + vm.actionId = key.id + vm.actionName = key.name + vm.startRunAction() + } + } + ActionScreen(vm, actionName = key.name, onBack = { navigator.pop() }) + } + } + ) + } + MainActivityDialogs(activity = this@MainActivity) + MiuixPopupHost() + } + } + } + } + + @Composable + private fun HandleFlashIntent(navigator: Navigator) { + val intentVersion by intentState.collectAsState() + LaunchedEffect(intentVersion) { + val currentIntent = intent ?: return@LaunchedEffect + if (currentIntent.action == FlashUtils.INTENT_FLASH) { + val action = currentIntent.getStringExtra(FlashUtils.EXTRA_FLASH_ACTION) + ?: return@LaunchedEffect + val uri = currentIntent.getStringExtra(FlashUtils.EXTRA_FLASH_URI) + navigator.push(Route.Flash(action, uri)) + currentIntent.action = null + } + } + } + + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + setIntent(intent) + intentState.value += 1 + } + + private fun getInitialTab(intent: Intent?): Int { + val section = if (intent?.action == Intent.ACTION_APPLICATION_PREFERENCES) { + Const.Nav.SETTINGS + } else { + intent?.getStringExtra(Const.Key.OPEN_SECTION) + } + return when (section) { + Const.Nav.SUPERUSER -> Tab.SUPERUSER.ordinal + Const.Nav.MODULES -> Tab.MODULES.ordinal + Const.Nav.SETTINGS -> Tab.SETTINGS.ordinal + else -> Tab.HOME.ordinal + } + } + + @SuppressLint("InlinedApi") + override fun showInvalidStateMessage() { + showInvalidState.value = true + } + + internal fun handleInvalidStateInstall() { + extension.withPermission(REQUEST_INSTALL_PACKAGES) { + if (!it) { + toast(CoreR.string.install_unknown_denied, Toast.LENGTH_SHORT) + showInvalidState.value = true + } else { + lifecycleScope.launch { + if (!AppMigration.restoreApp(this@MainActivity)) { + toast(CoreR.string.failure, Toast.LENGTH_LONG) + } + } + } + } + } + + private fun showUnsupportedMessage() { + val messages = mutableListOf>() + + if (Info.env.isUnsupported) { + messages.add(CoreR.string.unsupport_magisk_title to CoreR.string.unsupport_magisk_msg) + } + if (!Info.isEmulator && Info.env.isActive && System.getenv("PATH") + ?.split(':') + ?.filterNot { java.io.File("$it/magisk").exists() } + ?.any { java.io.File("$it/su").exists() } == true) { + messages.add(CoreR.string.unsupport_general_title to CoreR.string.unsupport_other_su_msg) + } + if (applicationInfo.flags and ApplicationInfo.FLAG_SYSTEM != 0) { + messages.add(CoreR.string.unsupport_general_title to CoreR.string.unsupport_system_app_msg) + } + if (applicationInfo.flags and ApplicationInfo.FLAG_EXTERNAL_STORAGE != 0) { + messages.add(CoreR.string.unsupport_general_title to CoreR.string.unsupport_external_storage_msg) + } + + if (messages.isNotEmpty()) { + showUnsupported.value = messages + } + } + + private fun askForHomeShortcut() { + if (isRunningAsStub && !Config.askedHome && + ShortcutManagerCompat.isRequestPinShortcutSupported(this)) { + Config.askedHome = true + showShortcutPrompt.value = true + } + } +} + +@Composable +private fun MainActivityDialogs(activity: MainActivity) { + val showInvalid by activity.showInvalidState.collectAsState() + val unsupportedMessages by activity.showUnsupported.collectAsState() + val showShortcut by activity.showShortcutPrompt.collectAsState() + + val invalidDialog = com.topjohnwu.magisk.ui.component.rememberConfirmDialog( + onConfirm = { + activity.showInvalidState.value = false + activity.handleInvalidStateInstall() + }, + onDismiss = {} + ) + + LaunchedEffect(showInvalid) { + if (showInvalid) { + invalidDialog.showConfirm( + title = activity.getString(CoreR.string.unsupport_nonroot_stub_title), + content = activity.getString(CoreR.string.unsupport_nonroot_stub_msg), + confirm = activity.getString(CoreR.string.install), + ) + } + } + + for ((index, pair) in unsupportedMessages.withIndex()) { + val (titleRes, msgRes) = pair + val show = rememberSaveable { androidx.compose.runtime.mutableStateOf(true) } + com.topjohnwu.magisk.ui.component.rememberConfirmDialog( + onConfirm = { show.value = false }, + ).also { dialog -> + LaunchedEffect(Unit) { + dialog.showConfirm( + title = activity.getString(titleRes), + content = activity.getString(msgRes), + ) + } + } + } + + val shortcutDialog = com.topjohnwu.magisk.ui.component.rememberConfirmDialog( + onConfirm = { + activity.showShortcutPrompt.value = false + Shortcuts.addHomeIcon(activity) + }, + onDismiss = { activity.showShortcutPrompt.value = false } + ) + + LaunchedEffect(showShortcut) { + if (showShortcut) { + shortcutDialog.showConfirm( + title = activity.getString(CoreR.string.add_shortcut_title), + content = activity.getString(CoreR.string.add_shortcut_msg), + ) + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/MainScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/MainScreen.kt new file mode 100644 index 000000000..a8668eb03 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/MainScreen.kt @@ -0,0 +1,227 @@ +package com.topjohnwu.magisk.ui + +import androidx.compose.animation.animateColorAsState +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.navigationBars +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.pager.HorizontalPager +import androidx.compose.foundation.pager.PagerState +import androidx.compose.foundation.pager.rememberPagerState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.draw.shadow +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.res.vectorResource +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.lifecycle.viewmodel.compose.viewModel +import com.topjohnwu.magisk.R +import com.topjohnwu.magisk.arch.VMFactory +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.model.module.LocalModule +import com.topjohnwu.magisk.ui.home.HomeScreen +import com.topjohnwu.magisk.ui.home.HomeViewModel +import com.topjohnwu.magisk.ui.install.InstallViewModel +import com.topjohnwu.magisk.ui.log.LogScreen +import com.topjohnwu.magisk.ui.log.LogViewModel +import com.topjohnwu.magisk.ui.module.ModuleScreen +import com.topjohnwu.magisk.ui.module.ModuleViewModel +import com.topjohnwu.magisk.ui.navigation.CollectNavEvents +import com.topjohnwu.magisk.ui.navigation.LocalNavigator +import com.topjohnwu.magisk.ui.settings.SettingsScreen +import com.topjohnwu.magisk.ui.settings.SettingsViewModel +import com.topjohnwu.magisk.ui.superuser.SuperuserScreen +import com.topjohnwu.magisk.ui.superuser.SuperuserViewModel +import kotlinx.coroutines.launch +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +enum class Tab(val titleRes: Int, val iconRes: Int) { + MODULES(CoreR.string.modules, R.drawable.ic_module_outlined_md2), + SUPERUSER(CoreR.string.superuser, R.drawable.ic_superuser_outlined_md2), + HOME(CoreR.string.section_home, R.drawable.ic_home_outlined_md2), + LOG(CoreR.string.logs, R.drawable.ic_bug_outlined_md2), + SETTINGS(CoreR.string.settings, R.drawable.ic_settings_outlined_md2); +} + +@Composable +fun MainScreen(initialTab: Int = Tab.HOME.ordinal) { + val navigator = LocalNavigator.current + val visibleTabs = remember { + Tab.entries.filter { tab -> + when (tab) { + Tab.SUPERUSER -> Info.showSuperUser + Tab.MODULES -> Info.env.isActive && LocalModule.loaded() + else -> true + } + } + } + val initialPage = visibleTabs.indexOf(Tab.entries[initialTab]).coerceAtLeast(0) + val pagerState = rememberPagerState(initialPage = initialPage, pageCount = { visibleTabs.size }) + + Box(modifier = Modifier.fillMaxSize()) { + HorizontalPager( + state = pagerState, + modifier = Modifier.fillMaxSize(), + beyondViewportPageCount = visibleTabs.size - 1, + userScrollEnabled = true, + ) { page -> + when (visibleTabs[page]) { + Tab.HOME -> { + val vm: HomeViewModel = viewModel(factory = VMFactory) + val installVm: InstallViewModel = viewModel(factory = VMFactory) + LaunchedEffect(Unit) { vm.startLoading() } + CollectNavEvents(vm, navigator) + CollectNavEvents(installVm, navigator) + HomeScreen(vm, installVm) + } + Tab.SUPERUSER -> { + val activity = LocalContext.current as MainActivity + val vm: SuperuserViewModel = viewModel(viewModelStoreOwner = activity, factory = VMFactory) + LaunchedEffect(Unit) { + vm.authenticate = { onSuccess -> + activity.extension.withAuthentication { if (it) onSuccess() } + } + vm.startLoading() + } + SuperuserScreen(vm) + } + Tab.LOG -> { + val vm: LogViewModel = viewModel(factory = VMFactory) + LaunchedEffect(Unit) { vm.startLoading() } + LogScreen(vm) + } + Tab.MODULES -> { + val vm: ModuleViewModel = viewModel(factory = VMFactory) + LaunchedEffect(Unit) { vm.startLoading() } + CollectNavEvents(vm, navigator) + ModuleScreen(vm) + } + Tab.SETTINGS -> { + val activity = LocalContext.current as MainActivity + val vm: SettingsViewModel = viewModel(factory = VMFactory) + LaunchedEffect(Unit) { + vm.authenticate = { onSuccess -> + activity.extension.withAuthentication { if (it) onSuccess() } + } + } + CollectNavEvents(vm, navigator) + SettingsScreen(vm) + } + } + } + + FloatingNavigationBar( + pagerState = pagerState, + visibleTabs = visibleTabs, + modifier = Modifier.align(Alignment.BottomCenter) + ) + } +} + +@Composable +private fun FloatingNavigationBar( + pagerState: PagerState, + visibleTabs: List, + modifier: Modifier = Modifier +) { + val scope = rememberCoroutineScope() + val shape = RoundedCornerShape(28.dp) + val navBarInset = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding() + + Row( + modifier = modifier + .padding(bottom = navBarInset + 12.dp, start = 24.dp, end = 24.dp) + .shadow(elevation = 6.dp, shape = shape) + .clip(shape) + .background(MiuixTheme.colorScheme.surfaceContainer) + .fillMaxWidth() + .height(64.dp) + .padding(horizontal = 4.dp), + horizontalArrangement = Arrangement.SpaceEvenly, + verticalAlignment = Alignment.CenterVertically + ) { + visibleTabs.forEachIndexed { index, tab -> + FloatingNavItem( + icon = ImageVector.vectorResource(tab.iconRes), + label = stringResource(tab.titleRes), + selected = pagerState.currentPage == index, + enabled = true, + onClick = { scope.launch { pagerState.animateScrollToPage(index) } }, + modifier = Modifier.weight(1f) + ) + } + } +} + +@Composable +private fun FloatingNavItem( + icon: ImageVector, + label: String, + selected: Boolean, + enabled: Boolean, + onClick: () -> Unit, + modifier: Modifier = Modifier +) { + val contentColor by animateColorAsState( + targetValue = when { + !enabled -> MiuixTheme.colorScheme.disabledOnSecondaryVariant + selected -> MiuixTheme.colorScheme.primary + else -> MiuixTheme.colorScheme.onSurfaceVariantActions + }, + animationSpec = tween(200), + label = "navItemColor" + ) + + Column( + modifier = modifier + .clickable( + enabled = enabled, + indication = null, + interactionSource = remember { MutableInteractionSource() }, + role = Role.Tab, + onClick = onClick, + ), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center, + ) { + Icon( + imageVector = icon, + contentDescription = label, + modifier = Modifier.size(24.dp), + tint = contentColor, + ) + Spacer(Modifier.height(2.dp)) + Text( + text = label, + fontSize = 11.sp, + color = contentColor, + ) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/component/Dialog.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/component/Dialog.kt new file mode 100644 index 000000000..042fa0518 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/component/Dialog.kt @@ -0,0 +1,374 @@ +package com.topjohnwu.magisk.ui.component + +import android.widget.TextView +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.WindowInsetsSides +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.only +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.systemBars +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.windowInsetsPadding +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.toArgb +import androidx.compose.ui.layout.Layout +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.compose.ui.viewinterop.AndroidView +import com.topjohnwu.magisk.core.di.ServiceLocator +import kotlinx.coroutines.CancellableContinuation +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.async +import kotlinx.coroutines.channels.Channel +import kotlinx.coroutines.flow.consumeAsFlow +import kotlinx.coroutines.flow.onEach +import kotlinx.coroutines.launch +import kotlinx.coroutines.suspendCancellableCoroutine +import kotlinx.coroutines.withContext +import timber.log.Timber +import top.yukonga.miuix.kmp.basic.ButtonDefaults +import top.yukonga.miuix.kmp.basic.InfiniteProgressIndicator +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TextButton +import top.yukonga.miuix.kmp.extra.SuperDialog +import top.yukonga.miuix.kmp.theme.MiuixTheme +import java.io.IOException +import kotlin.coroutines.resume + +sealed interface ConfirmResult { + data object Confirmed : ConfirmResult + data object Canceled : ConfirmResult +} + +data class DialogVisuals( + val title: String = "", + val content: String? = null, + val markdown: Boolean = false, + val confirm: String? = null, + val dismiss: String? = null, +) + +interface LoadingDialogHandle { + suspend fun withLoading(block: suspend () -> R): R +} + +interface ConfirmDialogHandle { + fun showConfirm( + title: String, + content: String? = null, + markdown: Boolean = false, + confirm: String? = null, + dismiss: String? = null + ) + + suspend fun awaitConfirm( + title: String, + content: String? = null, + markdown: Boolean = false, + confirm: String? = null, + dismiss: String? = null + ): ConfirmResult +} + +private class LoadingDialogHandleImpl( + private val visible: MutableState, + private val coroutineScope: CoroutineScope +) : LoadingDialogHandle { + override suspend fun withLoading(block: suspend () -> R): R { + return coroutineScope.async { + try { + visible.value = true + block() + } finally { + visible.value = false + } + }.await() + } +} + +private class ConfirmDialogHandleImpl( + private val visible: MutableState, + private val coroutineScope: CoroutineScope, + private val callback: ConfirmCallback, + private val resultChannel: Channel +) : ConfirmDialogHandle { + + var visuals by mutableStateOf(DialogVisuals()) + private set + + private var awaitContinuation: CancellableContinuation? = null + + init { + coroutineScope.launch { + resultChannel + .consumeAsFlow() + .onEach { result -> + awaitContinuation?.let { + awaitContinuation = null + if (it.isActive) it.resume(result) + } + } + .onEach { visible.value = false } + .collect { result -> + when (result) { + ConfirmResult.Confirmed -> callback.onConfirm?.invoke() + ConfirmResult.Canceled -> callback.onDismiss?.invoke() + } + } + } + } + + override fun showConfirm( + title: String, + content: String?, + markdown: Boolean, + confirm: String?, + dismiss: String? + ) { + coroutineScope.launch { + visuals = DialogVisuals(title, content, markdown, confirm, dismiss) + visible.value = true + } + } + + override suspend fun awaitConfirm( + title: String, + content: String?, + markdown: Boolean, + confirm: String?, + dismiss: String? + ): ConfirmResult { + coroutineScope.launch { + visuals = DialogVisuals(title, content, markdown, confirm, dismiss) + visible.value = true + } + return suspendCancellableCoroutine { cont -> + awaitContinuation = cont.apply { + invokeOnCancellation { visible.value = false } + } + } + } +} + +interface ConfirmCallback { + val onConfirm: (() -> Unit)? + val onDismiss: (() -> Unit)? +} + +@Composable +fun rememberConfirmCallback( + onConfirm: (() -> Unit)? = null, + onDismiss: (() -> Unit)? = null +): ConfirmCallback { + val currentOnConfirm by rememberUpdatedState(onConfirm) + val currentOnDismiss by rememberUpdatedState(onDismiss) + return remember { + object : ConfirmCallback { + override val onConfirm get() = currentOnConfirm + override val onDismiss get() = currentOnDismiss + } + } +} + +@Composable +fun rememberLoadingDialog(): LoadingDialogHandle { + val visible = remember { mutableStateOf(false) } + val scope = rememberCoroutineScope() + LoadingDialog(visible) + return remember { LoadingDialogHandleImpl(visible, scope) } +} + +@Composable +fun rememberConfirmDialog( + onConfirm: (() -> Unit)? = null, + onDismiss: (() -> Unit)? = null +): ConfirmDialogHandle { + return rememberConfirmDialog(rememberConfirmCallback(onConfirm, onDismiss)) +} + +@Composable +fun rememberConfirmDialog(callback: ConfirmCallback): ConfirmDialogHandle { + val visible = rememberSaveable { mutableStateOf(false) } + val scope = rememberCoroutineScope() + val resultChannel = remember { Channel() } + + val handle = remember { + ConfirmDialogHandleImpl(visible, scope, callback, resultChannel) + } + + if (visible.value) { + ConfirmDialogContent( + visuals = handle.visuals, + confirm = { scope.launch { resultChannel.send(ConfirmResult.Confirmed) } }, + dismiss = { scope.launch { resultChannel.send(ConfirmResult.Canceled) } }, + showDialog = visible + ) + } + + return handle +} + +@Composable +private fun LoadingDialog(showDialog: MutableState) { + SuperDialog( + show = showDialog, + onDismissRequest = {}, + content = { + Box( + modifier = Modifier.fillMaxWidth(), + contentAlignment = Alignment.CenterStart + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.Start, + ) { + InfiniteProgressIndicator( + color = MiuixTheme.colorScheme.onBackground + ) + Text( + modifier = Modifier.padding(start = 12.dp), + text = stringResource(com.topjohnwu.magisk.core.R.string.loading), + ) + } + } + } + ) +} + +@Composable +private fun ConfirmDialogContent( + visuals: DialogVisuals, + confirm: () -> Unit, + dismiss: () -> Unit, + showDialog: MutableState +) { + SuperDialog( + modifier = Modifier.windowInsetsPadding(WindowInsets.systemBars.only(WindowInsetsSides.Top)), + show = showDialog, + title = visuals.title, + onDismissRequest = { + dismiss() + showDialog.value = false + }, + content = { + Layout( + content = { + visuals.content?.let { content -> + if (visuals.markdown) { + MarkdownText(content) + } else { + Text( + text = content, + color = MiuixTheme.colorScheme.onSurface, + ) + } + } + Row( + horizontalArrangement = Arrangement.SpaceBetween, + modifier = Modifier.padding(top = 12.dp) + ) { + TextButton( + text = visuals.dismiss + ?: stringResource(android.R.string.cancel), + onClick = { + dismiss() + showDialog.value = false + }, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = visuals.confirm + ?: stringResource(android.R.string.ok), + onClick = { + confirm() + showDialog.value = false + }, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } + ) { measurables, constraints -> + if (measurables.size != 2) { + val button = measurables[0].measure(constraints) + layout(constraints.maxWidth, button.height) { + button.place(0, 0) + } + } else { + val button = measurables[1].measure(constraints) + val content = measurables[0].measure( + constraints.copy(maxHeight = constraints.maxHeight - button.height) + ) + layout(constraints.maxWidth, content.height + button.height) { + content.place(0, 0) + button.place(0, content.height) + } + } + } + } + ) +} + +@Composable +fun MarkdownText(text: String) { + val contentColor = MiuixTheme.colorScheme.onBackground.toArgb() + AndroidView( + factory = { context -> + TextView(context).apply { + setTextColor(contentColor) + ServiceLocator.markwon.setMarkdown(this, text) + } + }, + update = { textView -> + textView.setTextColor(contentColor) + ServiceLocator.markwon.setMarkdown(textView, text) + }, + modifier = Modifier + .fillMaxWidth() + .heightIn(max = 300.dp) + ) +} + +@Composable +fun MarkdownTextAsync(getMarkdownText: suspend () -> String) { + var mdText by remember { mutableStateOf(null) } + var error by remember { mutableStateOf(false) } + + LaunchedEffect(Unit) { + try { + mdText = withContext(Dispatchers.IO) { getMarkdownText() } + } catch (e: IOException) { + Timber.e(e) + error = true + } + } + + when { + error -> Text(stringResource(com.topjohnwu.magisk.core.R.string.download_file_error)) + mdText != null -> MarkdownText(mdText!!) + else -> Box( + modifier = Modifier.fillMaxWidth(), + contentAlignment = Alignment.Center + ) { + InfiniteProgressIndicator(color = MiuixTheme.colorScheme.onBackground) + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/component/MenuPositionProvider.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/component/MenuPositionProvider.kt new file mode 100644 index 000000000..6763878bc --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/component/MenuPositionProvider.kt @@ -0,0 +1,84 @@ +package com.topjohnwu.magisk.ui.component + +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.ui.unit.IntOffset +import androidx.compose.ui.unit.IntRect +import androidx.compose.ui.unit.IntSize +import androidx.compose.ui.unit.LayoutDirection +import androidx.compose.ui.unit.dp +import top.yukonga.miuix.kmp.basic.PopupPositionProvider + +object ListPopupDefaults { + val MenuPositionProvider = object : PopupPositionProvider { + override fun calculatePosition( + anchorBounds: IntRect, + windowBounds: IntRect, + layoutDirection: LayoutDirection, + popupContentSize: IntSize, + popupMargin: IntRect, + alignment: PopupPositionProvider.Align, + ): IntOffset { + val resolved = alignment.resolve(layoutDirection) + val offsetX: Int + val offsetY: Int + when (resolved) { + PopupPositionProvider.Align.TopStart -> { + offsetX = anchorBounds.left + popupMargin.left + offsetY = anchorBounds.bottom + popupMargin.top + } + PopupPositionProvider.Align.TopEnd -> { + offsetX = anchorBounds.right - popupContentSize.width - popupMargin.right + offsetY = anchorBounds.bottom + popupMargin.top + } + PopupPositionProvider.Align.BottomStart -> { + offsetX = anchorBounds.left + popupMargin.left + offsetY = anchorBounds.top - popupContentSize.height - popupMargin.bottom + } + PopupPositionProvider.Align.BottomEnd -> { + offsetX = anchorBounds.right - popupContentSize.width - popupMargin.right + offsetY = anchorBounds.top - popupContentSize.height - popupMargin.bottom + } + else -> { + offsetX = if (resolved == PopupPositionProvider.Align.End) { + anchorBounds.right - popupContentSize.width - popupMargin.right + } else { + anchorBounds.left + popupMargin.left + } + offsetY = if (windowBounds.bottom - anchorBounds.bottom > popupContentSize.height) { + anchorBounds.bottom + popupMargin.bottom + } else if (anchorBounds.top - windowBounds.top > popupContentSize.height) { + anchorBounds.top - popupContentSize.height - popupMargin.top + } else { + anchorBounds.top + anchorBounds.height / 2 - popupContentSize.height / 2 + } + } + } + return IntOffset( + x = offsetX.coerceIn( + windowBounds.left, + (windowBounds.right - popupContentSize.width - popupMargin.right) + .coerceAtLeast(windowBounds.left), + ), + y = offsetY.coerceIn( + (windowBounds.top + popupMargin.top) + .coerceAtMost(windowBounds.bottom - popupContentSize.height - popupMargin.bottom), + windowBounds.bottom - popupContentSize.height - popupMargin.bottom, + ), + ) + } + + override fun getMargins(): PaddingValues = PaddingValues(start = 20.dp) + } +} + +private fun PopupPositionProvider.Align.resolve(layoutDirection: LayoutDirection): PopupPositionProvider.Align { + if (layoutDirection == LayoutDirection.Ltr) return this + return when (this) { + PopupPositionProvider.Align.Start -> PopupPositionProvider.Align.End + PopupPositionProvider.Align.End -> PopupPositionProvider.Align.Start + PopupPositionProvider.Align.TopStart -> PopupPositionProvider.Align.TopEnd + PopupPositionProvider.Align.TopEnd -> PopupPositionProvider.Align.TopStart + PopupPositionProvider.Align.BottomStart -> PopupPositionProvider.Align.BottomEnd + PopupPositionProvider.Align.BottomEnd -> PopupPositionProvider.Align.BottomStart + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/AppProcessInfo.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/AppProcessInfo.kt new file mode 100644 index 000000000..df94740d6 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/AppProcessInfo.kt @@ -0,0 +1,134 @@ +package com.topjohnwu.magisk.ui.deny + +import android.annotation.SuppressLint +import android.content.pm.ApplicationInfo +import android.content.pm.ComponentInfo +import android.content.pm.PackageManager +import android.content.pm.PackageManager.GET_ACTIVITIES +import android.content.pm.PackageManager.GET_PROVIDERS +import android.content.pm.PackageManager.GET_RECEIVERS +import android.content.pm.PackageManager.GET_SERVICES +import android.content.pm.PackageManager.MATCH_DISABLED_COMPONENTS +import android.content.pm.PackageManager.MATCH_UNINSTALLED_PACKAGES +import android.content.pm.ServiceInfo +import android.graphics.drawable.Drawable +import androidx.core.os.ProcessCompat +import com.topjohnwu.magisk.core.ktx.getLabel +import java.util.Locale +import java.util.TreeSet + +class CmdlineListItem(line: String) { + val packageName: String + val process: String + + init { + val split = line.split(Regex("\\|"), 2) + packageName = split[0] + process = split.getOrElse(1) { packageName } + } +} + +const val ISOLATED_MAGIC = "isolated" + +@SuppressLint("InlinedApi") +class AppProcessInfo( + private val info: ApplicationInfo, + pm: PackageManager, + denyList: List +) : Comparable { + + private val denyList = denyList.filter { + it.packageName == info.packageName || it.packageName == ISOLATED_MAGIC + } + + val label = info.getLabel(pm) + val iconImage: Drawable = runCatching { info.loadIcon(pm) }.getOrDefault(pm.defaultActivityIcon) + val packageName: String get() = info.packageName + var firstInstallTime: Long = 0L + private set + var lastUpdateTime: Long = 0L + private set + val processes = fetchProcesses(pm) + + override fun compareTo(other: AppProcessInfo) = comparator.compare(this, other) + + fun isSystemApp() = info.flags and ApplicationInfo.FLAG_SYSTEM != 0 + + fun isApp() = ProcessCompat.isApplicationUid(info.uid) + + private fun createProcess(name: String, pkg: String = info.packageName) = + ProcessInfo(name, pkg, denyList.any { it.process == name && it.packageName == pkg }) + + private fun ComponentInfo.getProcName(): String = processName + ?: applicationInfo.processName + ?: applicationInfo.packageName + + private val ServiceInfo.isIsolated get() = (flags and ServiceInfo.FLAG_ISOLATED_PROCESS) != 0 + private val ServiceInfo.useAppZygote get() = (flags and ServiceInfo.FLAG_USE_APP_ZYGOTE) != 0 + + private fun Array?.toProcessList() = + orEmpty().map { createProcess(it.getProcName()) } + + private fun Array?.toProcessList(): List { + if (this == null) return emptyList() + val result = mutableListOf() + var hasIsolated = false + for (si in this) { + if (si.isIsolated) { + if (si.useAppZygote) { + val proc = info.processName ?: info.packageName + result.add(createProcess("${proc}_zygote")) + } else { + hasIsolated = true + } + } else { + result.add(createProcess(si.getProcName())) + } + } + if (hasIsolated) { + val prefix = "${info.processName ?: info.packageName}:" + val isEnabled = denyList.any { + it.packageName == ISOLATED_MAGIC && it.process.startsWith(prefix) + } + result.add(ProcessInfo(prefix, ISOLATED_MAGIC, isEnabled)) + } + return result + } + + private fun fetchProcesses(pm: PackageManager): Collection { + val flag = MATCH_DISABLED_COMPONENTS or MATCH_UNINSTALLED_PACKAGES or + GET_ACTIVITIES or GET_SERVICES or GET_RECEIVERS or GET_PROVIDERS + val packageInfo = try { + pm.getPackageInfo(info.packageName, flag) + } catch (e: Exception) { + // Exceed binder data transfer limit, parse the package locally + pm.getPackageArchiveInfo(info.sourceDir, flag) ?: return emptyList() + } + + firstInstallTime = packageInfo.firstInstallTime + lastUpdateTime = packageInfo.lastUpdateTime + + val processSet = TreeSet(compareBy({ it.name }, { it.isIsolated })) + processSet += packageInfo.activities.toProcessList() + processSet += packageInfo.services.toProcessList() + processSet += packageInfo.receivers.toProcessList() + processSet += packageInfo.providers.toProcessList() + return processSet + } + + companion object { + private val comparator = compareBy( + { it.label.lowercase(Locale.ROOT) }, + { it.info.packageName } + ) + } +} + +data class ProcessInfo( + val name: String, + val packageName: String, + var isEnabled: Boolean +) { + val isIsolated = packageName == ISOLATED_MAGIC + val isAppZygote = name.endsWith("_zygote") +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/DenyListScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/DenyListScreen.kt new file mode 100644 index 000000000..55583abc9 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/DenyListScreen.kt @@ -0,0 +1,322 @@ +package com.topjohnwu.magisk.ui.deny + +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.foundation.Image +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.input.nestedscroll.nestedScroll +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.state.ToggleableState +import androidx.compose.ui.unit.dp +import com.topjohnwu.magisk.ui.component.ListPopupDefaults.MenuPositionProvider +import com.topjohnwu.magisk.ui.util.rememberDrawablePainter +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.Checkbox +import top.yukonga.miuix.kmp.basic.CircularProgressIndicator +import top.yukonga.miuix.kmp.basic.DropdownImpl +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.IconButton +import top.yukonga.miuix.kmp.basic.LinearProgressIndicator +import top.yukonga.miuix.kmp.basic.ListPopupColumn +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.PopupPositionProvider +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TopAppBar +import top.yukonga.miuix.kmp.extra.SuperListPopup +import top.yukonga.miuix.kmp.icon.MiuixIcons +import top.yukonga.miuix.kmp.icon.extended.Back +import top.yukonga.miuix.kmp.icon.extended.Sort +import top.yukonga.miuix.kmp.icon.extended.Tune +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun DenyListScreen(viewModel: DenyListViewModel, onBack: () -> Unit) { + val loading by viewModel.loading.collectAsState() + val apps by viewModel.filteredApps.collectAsState() + val query by viewModel.query.collectAsState() + val showSystem by viewModel.showSystem.collectAsState() + val showOS by viewModel.showOS.collectAsState() + val sortBy by viewModel.sortBy.collectAsState() + val sortReverse by viewModel.sortReverse.collectAsState() + + val showSortMenu = remember { mutableStateOf(false) } + val showFilterMenu = remember { mutableStateOf(false) } + + val scrollBehavior = MiuixScrollBehavior() + Scaffold( + topBar = { + TopAppBar( + title = stringResource(CoreR.string.denylist), + navigationIcon = { + IconButton( + modifier = Modifier.padding(start = 16.dp), + onClick = onBack + ) { + Icon( + imageVector = MiuixIcons.Back, + contentDescription = null, + tint = MiuixTheme.colorScheme.onBackground + ) + } + }, + actions = { + Box { + IconButton( + onClick = { showSortMenu.value = true }, + holdDownState = showSortMenu.value, + ) { + Icon( + imageVector = MiuixIcons.Sort, + contentDescription = stringResource(CoreR.string.menu_sort), + ) + } + SuperListPopup( + show = showSortMenu, + popupPositionProvider = MenuPositionProvider, + alignment = PopupPositionProvider.Align.End, + onDismissRequest = { showSortMenu.value = false } + ) { + ListPopupColumn { + val sortOptions = listOf( + CoreR.string.sort_by_name to SortBy.NAME, + CoreR.string.sort_by_package_name to SortBy.PACKAGE_NAME, + CoreR.string.sort_by_install_time to SortBy.INSTALL_TIME, + CoreR.string.sort_by_update_time to SortBy.UPDATE_TIME, + ) + val totalSize = sortOptions.size + 1 + sortOptions.forEachIndexed { index, (resId, sort) -> + DropdownImpl( + text = stringResource(resId), + optionSize = totalSize, + isSelected = sortBy == sort, + index = index, + onSelectedIndexChange = { + viewModel.setSortBy(sort) + showSortMenu.value = false + } + ) + } + DropdownImpl( + text = stringResource(CoreR.string.sort_reverse), + optionSize = totalSize, + isSelected = sortReverse, + index = sortOptions.size, + onSelectedIndexChange = { + viewModel.toggleSortReverse() + showSortMenu.value = false + } + ) + } + } + } + + Box { + IconButton( + modifier = Modifier.padding(end = 16.dp), + onClick = { showFilterMenu.value = true }, + holdDownState = showFilterMenu.value, + ) { + Icon( + imageVector = MiuixIcons.Tune, + contentDescription = stringResource(CoreR.string.hide_filter_hint), + ) + } + SuperListPopup( + show = showFilterMenu, + popupPositionProvider = MenuPositionProvider, + alignment = PopupPositionProvider.Align.End, + onDismissRequest = { showFilterMenu.value = false } + ) { + ListPopupColumn { + DropdownImpl( + text = stringResource(CoreR.string.show_system_app), + optionSize = 2, + isSelected = showSystem, + index = 0, + onSelectedIndexChange = { + viewModel.setShowSystem(!showSystem) + showFilterMenu.value = false + } + ) + DropdownImpl( + text = stringResource(CoreR.string.show_os_app), + optionSize = 2, + isSelected = showOS, + index = 1, + onSelectedIndexChange = { + if (!showOS && !showSystem) { + viewModel.setShowSystem(true) + } + viewModel.setShowOS(!showOS) + showFilterMenu.value = false + } + ) + } + } + } + }, + scrollBehavior = scrollBehavior + ) + }, + popupHost = { } + ) { padding -> + Column(modifier = Modifier.fillMaxSize().padding(padding)) { + SearchInput( + query = query, + onQueryChange = viewModel::setQuery, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 12.dp, vertical = 4.dp) + ) + + if (loading) { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center + ) { + Column(horizontalAlignment = Alignment.CenterHorizontally) { + Text( + text = stringResource(CoreR.string.loading), + style = MiuixTheme.textStyles.headline2 + ) + Spacer(Modifier.height(16.dp)) + CircularProgressIndicator() + } + } + } else { + LazyColumn( + modifier = Modifier + .fillMaxSize() + .nestedScroll(scrollBehavior.nestedScrollConnection) + .padding(horizontal = 12.dp), + contentPadding = PaddingValues(top = 8.dp, bottom = 88.dp), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + items( + items = apps, + key = { it.info.packageName } + ) { app -> + DenyAppCard(app) + } + } + } + } + } +} + +@Composable +private fun SearchInput(query: String, onQueryChange: (String) -> Unit, modifier: Modifier = Modifier) { + top.yukonga.miuix.kmp.basic.TextField( + value = query, + onValueChange = onQueryChange, + modifier = modifier, + label = stringResource(CoreR.string.hide_filter_hint) + ) +} + +@Composable +private fun DenyAppCard(app: DenyAppState) { + Card(modifier = Modifier.fillMaxWidth()) { + Column { + if (app.checkedPercent > 0f) { + LinearProgressIndicator( + progress = app.checkedPercent, + modifier = Modifier.fillMaxWidth() + ) + } + + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { app.isExpanded = !app.isExpanded } + .padding(12.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Image( + painter = rememberDrawablePainter(app.info.iconImage), + contentDescription = app.info.label, + modifier = Modifier.size(40.dp) + ) + Spacer(Modifier.width(12.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + text = app.info.label, + style = MiuixTheme.textStyles.body1, + ) + Text( + text = app.info.packageName, + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary + ) + } + Spacer(Modifier.width(8.dp)) + Checkbox( + state = when { + app.itemsChecked == 0 -> ToggleableState.Off + app.checkedPercent < 1f -> ToggleableState.Indeterminate + else -> ToggleableState.On + }, + onClick = { app.toggleAll() } + ) + } + + AnimatedVisibility(visible = app.isExpanded) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(start = 52.dp) + ) { + app.processes.forEach { proc -> + ProcessRow(proc) + } + } + } + } + } +} + +@Composable +private fun ProcessRow(proc: DenyProcessState) { + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { proc.toggle() } + .padding(horizontal = 12.dp, vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = proc.displayName, + style = MiuixTheme.textStyles.body2, + color = if (proc.isEnabled) MiuixTheme.colorScheme.onSurface + else MiuixTheme.colorScheme.onSurfaceVariantSummary, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(8.dp)) + Checkbox( + state = ToggleableState(proc.isEnabled), + onClick = { proc.toggle() } + ) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/DenyListViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/DenyListViewModel.kt new file mode 100644 index 000000000..692fe2488 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/deny/DenyListViewModel.kt @@ -0,0 +1,162 @@ +package com.topjohnwu.magisk.ui.deny + +import android.annotation.SuppressLint +import android.content.pm.PackageManager.MATCH_UNINSTALLED_PACKAGES +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.AsyncLoadViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.ktx.concurrentMap +import com.topjohnwu.superuser.Shell +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.filter +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.flow.toCollection +import kotlinx.coroutines.withContext + +enum class SortBy { NAME, PACKAGE_NAME, INSTALL_TIME, UPDATE_TIME } + +class DenyListViewModel : AsyncLoadViewModel() { + + private val _loading = MutableStateFlow(true) + val loading: StateFlow = _loading.asStateFlow() + + private val _allApps = MutableStateFlow>(emptyList()) + + private val _query = MutableStateFlow("") + val query: StateFlow = _query.asStateFlow() + + private val _showSystem = MutableStateFlow(false) + val showSystem: StateFlow = _showSystem.asStateFlow() + + private val _showOS = MutableStateFlow(false) + val showOS: StateFlow = _showOS.asStateFlow() + + private val _sortBy = MutableStateFlow(SortBy.NAME) + val sortBy: StateFlow = _sortBy.asStateFlow() + + private val _sortReverse = MutableStateFlow(false) + val sortReverse: StateFlow = _sortReverse.asStateFlow() + + val filteredApps: StateFlow> = combine( + _allApps, _query, _showSystem, _showOS, _sortBy, _sortReverse + ) { args -> + @Suppress("UNCHECKED_CAST") + val apps = args[0] as List + val q = args[1] as String + val showSys = args[2] as Boolean + val showOS = args[3] as Boolean + val sort = args[4] as SortBy + val reverse = args[5] as Boolean + + val filtered = apps.filter { app -> + val passFilter = app.isChecked || + ((showSys || !app.info.isSystemApp()) && + ((showSys && showOS) || app.info.isApp())) + val passQuery = q.isBlank() || + app.info.label.contains(q, true) || + app.info.packageName.contains(q, true) || + app.processes.any { it.process.name.contains(q, true) } + passFilter && passQuery + } + + val secondary: Comparator = when (sort) { + SortBy.NAME -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.info.label } + SortBy.PACKAGE_NAME -> compareBy(String.CASE_INSENSITIVE_ORDER) { it.info.packageName } + SortBy.INSTALL_TIME -> compareByDescending { it.info.firstInstallTime } + SortBy.UPDATE_TIME -> compareByDescending { it.info.lastUpdateTime } + } + val comparator = compareBy { it.itemsChecked == 0 } + .then(if (reverse) secondary.reversed() else secondary) + filtered.sortedWith(comparator) + }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList()) + + fun setQuery(q: String) { _query.value = q } + fun setShowSystem(v: Boolean) { + _showSystem.value = v + if (!v) _showOS.value = false + } + fun setShowOS(v: Boolean) { _showOS.value = v } + fun setSortBy(s: SortBy) { _sortBy.value = s } + fun toggleSortReverse() { _sortReverse.value = !_sortReverse.value } + + @SuppressLint("InlinedApi") + override suspend fun doLoadWork() { + _loading.value = true + val apps = withContext(Dispatchers.Default) { + val pm = AppContext.packageManager + val denyList = Shell.cmd("magisk --denylist ls").exec().out + .map { CmdlineListItem(it) } + val apps = pm.getInstalledApplications(MATCH_UNINSTALLED_PACKAGES).run { + asFlow() + .filter { AppContext.packageName != it.packageName } + .concurrentMap { AppProcessInfo(it, pm, denyList) } + .filter { it.processes.isNotEmpty() } + .concurrentMap { DenyAppState(it) } + .toCollection(ArrayList(size)) + } + apps.sortWith(compareBy( + { it.processes.count { p -> p.isEnabled } == 0 }, + { it.info } + )) + apps + } + _allApps.value = apps + _loading.value = false + } +} + +class DenyAppState(val info: AppProcessInfo) : Comparable { + val processes = info.processes.map { DenyProcessState(it) } + var isExpanded by mutableStateOf(false) + + val itemsChecked: Int get() = processes.count { it.isEnabled } + val isChecked: Boolean get() = itemsChecked > 0 + val checkedPercent: Float get() = if (processes.isEmpty()) 0f else itemsChecked.toFloat() / processes.size + + fun toggleAll() { + if (isChecked) { + Shell.cmd("magisk --denylist rm ${info.packageName}").submit() + processes.filter { it.isEnabled }.forEach { proc -> + if (proc.process.isIsolated) { + proc.toggle() + } else { + proc.isEnabled = false + } + } + } else { + processes.filterNot { it.isEnabled }.forEach { it.toggle() } + } + } + + override fun compareTo(other: DenyAppState) = comparator.compare(this, other) + + companion object { + private val comparator = compareBy( + { it.itemsChecked == 0 }, + { it.info } + ) + } +} + +class DenyProcessState(val process: ProcessInfo) { + var isEnabled by mutableStateOf(process.isEnabled) + + val displayName: String = + if (process.isIsolated) "(isolated) ${process.name}*" else process.name + + fun toggle() { + isEnabled = !isEnabled + val arg = if (isEnabled) "add" else "rm" + val (name, pkg) = process + Shell.cmd("magisk --denylist $arg $pkg \'$name\'").submit() + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashScreen.kt new file mode 100644 index 000000000..b7dc4e524 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashScreen.kt @@ -0,0 +1,134 @@ +package com.topjohnwu.magisk.ui.flash + +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.rememberScrollState +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.topjohnwu.magisk.R +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.ui.terminal.TerminalScreen +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.IconButton +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.SmallTopAppBar +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.icon.MiuixIcons +import top.yukonga.miuix.kmp.icon.extended.Back +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun FlashScreen(viewModel: FlashViewModel, action: String, onBack: () -> Unit) { + val flashState by viewModel.flashState.collectAsState() + val showReboot by viewModel.showReboot.collectAsState() + val finished = flashState != FlashViewModel.State.FLASHING + val useTerminal = action == Const.Value.FLASH_ZIP + + val statusText = when (flashState) { + FlashViewModel.State.FLASHING -> stringResource(CoreR.string.flashing) + FlashViewModel.State.SUCCESS -> stringResource(CoreR.string.done) + FlashViewModel.State.FAILED -> stringResource(CoreR.string.failure) + } + + val scrollBehavior = MiuixScrollBehavior() + Scaffold( + topBar = { + SmallTopAppBar( + title = "${stringResource(CoreR.string.flash_screen_title)} - $statusText", + navigationIcon = { + IconButton( + modifier = Modifier.padding(start = 16.dp), + onClick = onBack + ) { + Icon( + imageVector = MiuixIcons.Back, + contentDescription = null, + tint = MiuixTheme.colorScheme.onBackground + ) + } + }, + actions = { + if (finished) { + IconButton( + modifier = Modifier.padding(end = 4.dp), + onClick = { viewModel.saveLog() } + ) { + Icon( + painter = painterResource(R.drawable.ic_save_md2), + contentDescription = stringResource(CoreR.string.menuSaveLog), + tint = MiuixTheme.colorScheme.onBackground + ) + } + } + if (flashState == FlashViewModel.State.SUCCESS && showReboot) { + IconButton( + modifier = Modifier.padding(end = 16.dp), + onClick = { viewModel.restartPressed() } + ) { + Icon( + painter = painterResource(R.drawable.ic_restart), + contentDescription = stringResource(CoreR.string.reboot), + tint = MiuixTheme.colorScheme.onBackground + ) + } + } + }, + scrollBehavior = scrollBehavior + ) + }, + popupHost = { } + ) { padding -> + if (useTerminal) { + TerminalScreen( + modifier = Modifier + .fillMaxSize() + .padding(padding), + onEmulatorCreated = { viewModel.onEmulatorCreated(it) }, + ) + } else { + val items = viewModel.consoleItems + val listState = rememberLazyListState() + + LaunchedEffect(items.size) { + if (items.isNotEmpty()) { + listState.animateScrollToItem(items.size - 1) + } + } + + LazyColumn( + state = listState, + modifier = Modifier + .fillMaxSize() + .padding(padding) + .horizontalScroll(rememberScrollState()) + .padding(horizontal = 8.dp, vertical = 4.dp) + ) { + itemsIndexed(items) { _, line -> + Text( + text = line, + fontFamily = FontFamily.Monospace, + fontSize = 12.sp, + lineHeight = 16.sp, + color = MiuixTheme.colorScheme.onSurface, + modifier = Modifier.fillMaxWidth() + ) + } + } + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashUtils.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashUtils.kt new file mode 100644 index 000000000..cfd06c0cf --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashUtils.kt @@ -0,0 +1,30 @@ +package com.topjohnwu.magisk.ui.flash + +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.net.Uri +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.core.cmp +import com.topjohnwu.magisk.ui.MainActivity + +object FlashUtils { + + const val INTENT_FLASH = "com.topjohnwu.magisk.intent.FLASH" + const val EXTRA_FLASH_ACTION = "flash_action" + const val EXTRA_FLASH_URI = "flash_uri" + + fun installIntent(context: Context, file: Uri): PendingIntent { + val intent = Intent(context, MainActivity::class.java).apply { + component = MainActivity::class.java.cmp(context.packageName) + action = INTENT_FLASH + putExtra(EXTRA_FLASH_ACTION, Const.Value.FLASH_ZIP) + putExtra(EXTRA_FLASH_URI, file.toString()) + flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP + } + return PendingIntent.getActivity( + context, file.hashCode(), intent, + PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT + ) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashViewModel.kt new file mode 100644 index 000000000..2eb6508a6 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/flash/FlashViewModel.kt @@ -0,0 +1,203 @@ +package com.topjohnwu.magisk.ui.flash + +import android.net.Uri +import androidx.compose.runtime.mutableStateListOf +import androidx.core.net.toFile +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.BaseViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.ktx.reboot +import com.topjohnwu.magisk.core.ktx.synchronized +import com.topjohnwu.magisk.core.ktx.timeFormatStandard +import com.topjohnwu.magisk.core.ktx.toTime +import com.topjohnwu.magisk.core.ktx.writeTo +import com.topjohnwu.magisk.core.tasks.MagiskInstaller +import com.topjohnwu.magisk.core.utils.MediaStoreUtils +import com.topjohnwu.magisk.core.utils.MediaStoreUtils.displayName +import com.topjohnwu.magisk.core.utils.MediaStoreUtils.inputStream +import com.topjohnwu.magisk.core.utils.MediaStoreUtils.outputStream +import com.topjohnwu.magisk.terminal.TerminalEmulator +import com.topjohnwu.magisk.terminal.appendLineOnMain +import com.topjohnwu.magisk.terminal.runSuCommand +import com.topjohnwu.superuser.CallbackList +import com.topjohnwu.superuser.Shell +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import timber.log.Timber +import java.io.File +import java.io.FileNotFoundException +import java.io.IOException + +class FlashViewModel : BaseViewModel() { + + enum class State { + FLASHING, SUCCESS, FAILED + } + + private val _flashState = MutableStateFlow(State.FLASHING) + val flashState: StateFlow = _flashState.asStateFlow() + + private val _showReboot = MutableStateFlow(Info.isRooted) + val showReboot: StateFlow = _showReboot.asStateFlow() + + var flashAction: String = "" + var flashUri: Uri? = null + + // --- TerminalScreen mode (FLASH_ZIP) --- + + private var emulator: TerminalEmulator? = null + private val emulatorReady = CompletableDeferred() + + fun onEmulatorCreated(emu: TerminalEmulator) { + emulator = emu + emulatorReady.complete(emu) + } + + // --- LazyColumn mode (MagiskInstaller) --- + + val consoleItems = mutableStateListOf() + private val logItems = mutableListOf().synchronized() + private val outItems = object : CallbackList() { + override fun onAddElement(e: String?) { + e ?: return + consoleItems.add(e) + logItems.add(e) + } + } + + // --- Shared --- + + fun startFlashing() { + val action = flashAction + val uri = flashUri + + viewModelScope.launch { + when (action) { + Const.Value.FLASH_ZIP -> { + uri ?: return@launch + flashZip(uri) + } + Const.Value.UNINSTALL -> { + _showReboot.value = false + onResult(withContext(Dispatchers.IO) { + MagiskInstaller.Uninstall(outItems, logItems).exec() + }) + } + Const.Value.FLASH_MAGISK -> { + onResult(withContext(Dispatchers.IO) { + if (Info.isEmulator) + MagiskInstaller.Emulator(outItems, logItems).exec() + else + MagiskInstaller.Direct(outItems, logItems).exec() + }) + } + Const.Value.FLASH_INACTIVE_SLOT -> { + _showReboot.value = false + onResult(withContext(Dispatchers.IO) { + MagiskInstaller.SecondSlot(outItems, logItems).exec() + }) + } + Const.Value.PATCH_FILE -> { + uri ?: return@launch + _showReboot.value = false + onResult(withContext(Dispatchers.IO) { + MagiskInstaller.Patch(uri, outItems, logItems).exec() + }) + } + } + } + } + + private fun onResult(success: Boolean) { + _flashState.value = if (success) State.SUCCESS else State.FAILED + } + + private suspend fun flashZip(uri: Uri) { + val emu = emulatorReady.await() + + val installDir = File(AppContext.cacheDir, "flash") + val result = withContext(Dispatchers.IO) { + try { + installDir.deleteRecursively() + installDir.mkdirs() + + val zipFile = if (uri.scheme == "file") { + uri.toFile() + } else { + File(installDir, "install.zip").also { + try { + uri.inputStream().writeTo(it) + } catch (e: IOException) { + val msg = if (e is FileNotFoundException) "Invalid Uri" else "Cannot copy to cache" + return@withContext msg to null + } + } + } + + val binary = File(installDir, "update-binary") + AppContext.assets.open("module_installer.sh").use { it.writeTo(binary) } + + val name = uri.displayName + null to Triple(installDir, zipFile, name) + } catch (e: IOException) { + Timber.e(e) + "Unable to extract files" to null + } + } + + val (error, prepResult) = result + if (prepResult == null) { + emu.appendLineOnMain("! ${error ?: "Installation failed"}") + _flashState.value = State.FAILED + return + } + + val (dir, zipFile, displayName) = prepResult + + val success = withContext(Dispatchers.IO) { + runSuCommand( + emu, + "echo '- Installing $displayName'; " + + "sh $dir/update-binary dummy 1 '${zipFile.absolutePath}'; " + + "EXIT=\$?; " + + "if [ \$EXIT -ne 0 ]; then echo '! Installation failed'; fi; " + + "exit \$EXIT" + ) + } + + Shell.cmd("cd /", "rm -rf $dir ${Const.TMPDIR}").submit() + _flashState.value = if (success) State.SUCCESS else State.FAILED + } + + fun saveLog() { + viewModelScope.launch(Dispatchers.IO) { + val name = "magisk_install_log_%s.log".format( + System.currentTimeMillis().toTime(timeFormatStandard) + ) + val file = MediaStoreUtils.getFile(name) + file.uri.outputStream().bufferedWriter().use { writer -> + val transcript = emulator?.screen?.transcriptText + if (transcript != null) { + writer.write(transcript) + } else { + synchronized(logItems) { + logItems.forEach { + writer.write(it) + writer.newLine() + } + } + } + } + showSnackbar(file.toString()) + } + } + + fun restartPressed() = reboot() +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/home/HomeScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/home/HomeScreen.kt new file mode 100644 index 000000000..c65b44ce5 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/home/HomeScreen.kt @@ -0,0 +1,1160 @@ +package com.topjohnwu.magisk.ui.home + +import android.content.ActivityNotFoundException +import android.content.Context +import android.content.Intent +import android.os.Build +import android.os.PowerManager +import android.widget.Toast +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.IntrinsicSize +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +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.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.DpSize +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.core.content.getSystemService +import androidx.core.net.toUri +import com.topjohnwu.magisk.R +import com.topjohnwu.magisk.core.BuildConfig +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.download.DownloadEngine +import com.topjohnwu.magisk.core.download.Subject +import com.topjohnwu.magisk.core.ktx.reboot +import com.topjohnwu.magisk.core.ktx.toast +import com.topjohnwu.magisk.core.tasks.AppMigration +import com.topjohnwu.magisk.core.tasks.MagiskInstaller +import com.topjohnwu.magisk.ui.MainActivity +import com.topjohnwu.magisk.ui.component.ConfirmResult +import com.topjohnwu.magisk.ui.component.ListPopupDefaults.MenuPositionProvider +import com.topjohnwu.magisk.ui.component.LoadingDialogHandle +import com.topjohnwu.magisk.ui.component.MarkdownText +import com.topjohnwu.magisk.ui.component.MarkdownTextAsync +import com.topjohnwu.magisk.ui.component.rememberConfirmDialog +import com.topjohnwu.magisk.ui.component.rememberLoadingDialog +import com.topjohnwu.magisk.ui.flash.FlashUtils +import com.topjohnwu.magisk.ui.install.InstallViewModel +import kotlinx.coroutines.launch +import top.yukonga.miuix.kmp.basic.ButtonDefaults +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.Checkbox +import top.yukonga.miuix.kmp.basic.DropdownImpl +import top.yukonga.miuix.kmp.basic.HorizontalDivider +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.IconButton +import top.yukonga.miuix.kmp.basic.LinearProgressIndicator +import top.yukonga.miuix.kmp.basic.ListPopupColumn +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.PopupPositionProvider +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.SmallTitle +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TextButton +import top.yukonga.miuix.kmp.basic.TopAppBar +import top.yukonga.miuix.kmp.basic.VerticalDivider +import top.yukonga.miuix.kmp.extra.SuperArrow +import top.yukonga.miuix.kmp.extra.SuperBottomSheet +import top.yukonga.miuix.kmp.extra.SuperListPopup +import top.yukonga.miuix.kmp.icon.MiuixIcons +import top.yukonga.miuix.kmp.icon.extended.Close +import top.yukonga.miuix.kmp.icon.extended.Delete +import top.yukonga.miuix.kmp.icon.extended.Hide +import top.yukonga.miuix.kmp.icon.extended.Show +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun HomeScreen(viewModel: HomeViewModel, installVm: InstallViewModel) { + val uiState by viewModel.uiState.collectAsState() + val installUiState by installVm.uiState.collectAsState() + val context = LocalContext.current + val activity = context as MainActivity + val scrollBehavior = MiuixScrollBehavior() + val scope = rememberCoroutineScope() + val loadingDialog = rememberLoadingDialog() + val navigator = com.topjohnwu.magisk.ui.navigation.LocalNavigator.current + + val showUninstallDialog = rememberSaveable { mutableStateOf(false) } + val showManagerDialog = rememberSaveable { mutableStateOf(false) } + val showEnvFixDialog = rememberSaveable { mutableStateOf(false) } + var showHideDialog by rememberSaveable { mutableStateOf(false) } + var showRestoreDialog by rememberSaveable { mutableStateOf(false) } + val showInstallSheet = rememberSaveable { mutableStateOf(false) } + var envFixCode by remember { mutableIntStateOf(0) } + + val filePicker = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri -> + uri?.let { installVm.onPatchFileSelected(it) } + } + + val secondSlotDialog = rememberConfirmDialog() + val secondSlotTitle = stringResource(android.R.string.dialog_alert_title) + val secondSlotMsg = stringResource(CoreR.string.install_inactive_slot_msg) + + LaunchedEffect(installUiState.requestFilePicker) { + if (installUiState.requestFilePicker) { + filePicker.launch("*/*") + installVm.onFilePickerConsumed() + } + } + + LaunchedEffect(installUiState.showSecondSlotWarning) { + if (installUiState.showSecondSlotWarning) { + val result = secondSlotDialog.awaitConfirm(title = secondSlotTitle, content = secondSlotMsg) + installVm.onSecondSlotWarningConsumed() + if (result == ConfirmResult.Confirmed) { + installVm.install() + } + } + } + + LaunchedEffect(uiState.showUninstall) { + if (uiState.showUninstall) { + showUninstallDialog.value = true + viewModel.onUninstallConsumed() + } + } + LaunchedEffect(uiState.showManagerInstall) { + if (uiState.showManagerInstall) { + showManagerDialog.value = true + viewModel.onManagerInstallConsumed() + } + } + LaunchedEffect(uiState.envFixCode) { + if (uiState.envFixCode != 0) { + envFixCode = uiState.envFixCode + showEnvFixDialog.value = true + viewModel.onEnvFixConsumed() + } + } + LaunchedEffect(uiState.showHideRestore) { + if (uiState.showHideRestore) { + val hidden = context.packageName != BuildConfig.APP_PACKAGE_NAME + if (hidden) showRestoreDialog = true else showHideDialog = true + viewModel.onHideRestoreConsumed() + } + } + + if (showUninstallDialog.value) { + UninstallComposableDialog( + showDialog = showUninstallDialog, + activity = activity, + loadingDialog = loadingDialog, + ) + } + + if (showManagerDialog.value) { + ManagerInstallComposableDialog( + showDialog = showManagerDialog, + activity = activity, + ) + } + + if (showEnvFixDialog.value) { + EnvFixComposableDialog( + showDialog = showEnvFixDialog, + code = envFixCode, + activity = activity, + loadingDialog = loadingDialog, + onNavigateInstall = { showInstallSheet.value = true }, + ) + } + + if (showHideDialog) { + HideAppDialog( + onDismiss = { showHideDialog = false }, + onConfirm = { name -> + showHideDialog = false + scope.launch { + loadingDialog.withLoading { + AppMigration.patchAndHide(context, name) + } + } + } + ) + } + + if (showRestoreDialog) { + RestoreAppDialog( + onDismiss = { showRestoreDialog = false }, + onConfirm = { + showRestoreDialog = false + scope.launch { + loadingDialog.withLoading { + AppMigration.restoreApp(context) + } + } + } + ) + } + + Scaffold( + topBar = { + TopAppBar( + title = stringResource(CoreR.string.section_home), + scrollBehavior = scrollBehavior, + actions = { + if (Info.isRooted) { + RebootButton() + } + } + ) + }, + popupHost = { } + ) { padding -> + Column( + modifier = Modifier + .nestedScroll(scrollBehavior.nestedScrollConnection) + .padding(padding) + .verticalScroll(rememberScrollState()) + .padding(horizontal = 16.dp) + .padding(top = 12.dp, bottom = 88.dp), + verticalArrangement = Arrangement.spacedBy(12.dp) + ) { + if (uiState.isNoticeVisible) { + NoticeCard(onHide = viewModel::hideNotice) + } + + Row( + modifier = Modifier.height(IntrinsicSize.Max), + horizontalArrangement = Arrangement.spacedBy(12.dp) + ) { + CoreCard( + modifier = Modifier.weight(1f).fillMaxHeight(), + state = viewModel.magiskState, + version = viewModel.magiskInstalledVersion, + remoteVersion = if (viewModel.magiskState == HomeViewModel.State.OUTDATED) + "${BuildConfig.APP_VERSION_NAME} (${BuildConfig.APP_VERSION_CODE})" else null, + onInstallClicked = { showInstallSheet.value = true }, + onUninstallClicked = { viewModel.onDeletePressed() }, + ) + AppCard( + modifier = Modifier.weight(1f).fillMaxHeight(), + state = uiState.appState, + version = viewModel.managerInstalledVersion, + remoteVersion = if (uiState.appState == HomeViewModel.State.OUTDATED) + uiState.managerRemoteVersion else null, + progress = uiState.managerProgress, + isHidden = context.packageName != BuildConfig.APP_PACKAGE_NAME, + onManagerPressed = { viewModel.onManagerPressed() }, + onHideRestorePressed = viewModel::onHideRestorePressed, + ) + } + + SmallTitle(text = stringResource(CoreR.string.home_status_title)) + StatusCard() + + val showDonateSheet = rememberSaveable { mutableStateOf(false) } + + SmallTitle(text = stringResource(CoreR.string.home_support_title)) + Card(modifier = Modifier.fillMaxWidth()) { + SuperArrow( + title = stringResource(CoreR.string.documents), + onClick = { openLink(context, "https://topjohnwu.github.io/Magisk/") } + ) + SuperArrow( + title = stringResource(CoreR.string.report_bugs), + onClick = { openLink(context, "${Const.Url.SOURCE_CODE_URL}/issues") } + ) + SuperArrow( + title = stringResource(CoreR.string.donate), + onClick = { showDonateSheet.value = true } + ) + } + + SupportBottomSheet( + show = showDonateSheet, + onLinkClicked = { viewModel.onLinkPressed(it) } + ) + + SmallTitle(text = stringResource(CoreR.string.home_follow_title)) + DevelopersCard(onLinkClicked = { openLink(context, it) }) + } + } + + InstallBottomSheet( + show = showInstallSheet, + installVm = installVm, + installUiState = installUiState, + ) +} + +@Composable +private fun RebootButton() { + val showMenu = remember { mutableStateOf(false) } + val context = LocalContext.current + var safeModeEnabled by remember { mutableIntStateOf(Config.bootloop) } + + val showUserspace = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && + context.getSystemService()?.isRebootingUserspaceSupported == true + val showSafeMode = Const.Version.atLeast_28_0() + + val items = buildList { + add(RebootOption(CoreR.string.reboot) { reboot() }) + if (showUserspace) { + add(RebootOption(CoreR.string.reboot_userspace) { reboot("userspace") }) + } + add(RebootOption(CoreR.string.reboot_recovery) { reboot("recovery") }) + add(RebootOption(CoreR.string.reboot_bootloader) { reboot("bootloader") }) + add(RebootOption(CoreR.string.reboot_download) { reboot("download") }) + add(RebootOption(CoreR.string.reboot_edl) { reboot("edl") }) + if (showSafeMode) { + add(RebootOption(CoreR.string.reboot_safe_mode) { + val newVal = if (safeModeEnabled >= 2) 0 else 2 + Config.bootloop = newVal + safeModeEnabled = newVal + }) + } + } + + Box { + IconButton( + modifier = Modifier.padding(end = 16.dp), + onClick = { showMenu.value = true }, + holdDownState = showMenu.value, + ) { + Icon( + painter = painterResource(R.drawable.ic_restart), + contentDescription = stringResource(CoreR.string.reboot), + ) + } + SuperListPopup( + show = showMenu, + popupPositionProvider = MenuPositionProvider, + alignment = PopupPositionProvider.Align.End, + onDismissRequest = { showMenu.value = false } + ) { + ListPopupColumn { + items.forEachIndexed { index, item -> + val isSafeMode = item.labelRes == CoreR.string.reboot_safe_mode + DropdownImpl( + text = stringResource(item.labelRes), + optionSize = items.size, + isSelected = isSafeMode && safeModeEnabled >= 2, + index = index, + onSelectedIndexChange = { + item.action() + if (!isSafeMode) showMenu.value = false + } + ) + } + } + } + } +} + +private class RebootOption(val labelRes: Int, val action: () -> Unit) + +@Composable +private fun NoticeCard(onHide: () -> Unit) { + Box( + modifier = Modifier + .fillMaxWidth() + .background( + MiuixTheme.colorScheme.tertiaryContainer, + RoundedCornerShape(16.dp) + ) + .padding(start = 16.dp, top = 4.dp, bottom = 4.dp, end = 4.dp) + ) { + Row( + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = stringResource(CoreR.string.home_notice_content), + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onTertiaryContainer, + modifier = Modifier.weight(1f).padding(vertical = 8.dp) + ) + IconButton(onClick = onHide) { + Icon( + imageVector = MiuixIcons.Close, + contentDescription = stringResource(CoreR.string.hide), + modifier = Modifier.size(15.dp), + tint = MiuixTheme.colorScheme.onTertiaryContainer, + ) + } + } + } +} + +@Composable +private fun CoreCard( + modifier: Modifier = Modifier, + state: HomeViewModel.State, + version: String, + remoteVersion: String? = null, + onInstallClicked: () -> Unit, + onUninstallClicked: () -> Unit, +) { + val actionLabel = when (state) { + HomeViewModel.State.OUTDATED -> stringResource(CoreR.string.update) + HomeViewModel.State.INVALID -> stringResource(CoreR.string.install) + HomeViewModel.State.UP_TO_DATE -> stringResource(CoreR.string.reinstall) + HomeViewModel.State.LOADING -> null + } + val actionColor = when (state) { + HomeViewModel.State.OUTDATED, HomeViewModel.State.INVALID -> MiuixTheme.colorScheme.primary + else -> MiuixTheme.colorScheme.onSurfaceVariantActions + } + val uninstallEnabled = Info.env.isActive + + Card(modifier = modifier) { + Column(modifier = Modifier.fillMaxSize()) { + Box( + modifier = Modifier + .weight(1f) + .fillMaxWidth() + ) { + Column(modifier = Modifier.padding(16.dp)) { + Icon( + painter = painterResource(CoreR.drawable.ic_magisk_outline), + contentDescription = null, + modifier = Modifier.size(24.dp), + tint = MiuixTheme.colorScheme.primary + ) + Spacer(Modifier.height(8.dp)) + Text( + text = stringResource(CoreR.string.home_core_title), + style = MiuixTheme.textStyles.headline2, + ) + Text( + text = version.ifEmpty { stringResource(CoreR.string.not_available) }, + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + ) + } + Column( + modifier = Modifier.align(Alignment.TopEnd).padding(4.dp), + verticalArrangement = Arrangement.spacedBy(0.dp), + ) { + IconButton( + onClick = onUninstallClicked, + enabled = uninstallEnabled, + ) { + Icon( + imageVector = MiuixIcons.Delete, + contentDescription = null, + modifier = Modifier.size(18.dp), + tint = if (uninstallEnabled) MiuixTheme.colorScheme.error + else MiuixTheme.colorScheme.onSurfaceVariantActions, + ) + } + if (remoteVersion != null) { + UpdateBadge( + version = remoteVersion, + modifier = Modifier.align(Alignment.End).padding(end = 4.dp) + ) + } + } + } + + if (actionLabel != null) { + HorizontalDivider(thickness = 0.75.dp) + Text( + text = actionLabel, + style = MiuixTheme.textStyles.body2, + color = actionColor, + textAlign = TextAlign.Center, + maxLines = 1, + modifier = Modifier + .fillMaxWidth() + .height(44.dp) + .clickable(onClick = onInstallClicked) + .padding(horizontal = 12.dp, vertical = 12.dp) + ) + } + } + } +} + +@Composable +private fun AppCard( + modifier: Modifier = Modifier, + state: HomeViewModel.State, + version: String, + remoteVersion: String? = null, + progress: Int, + isHidden: Boolean, + onManagerPressed: () -> Unit, + onHideRestorePressed: () -> Unit, +) { + val actionLabel = when (state) { + HomeViewModel.State.OUTDATED -> stringResource(CoreR.string.update) + HomeViewModel.State.UP_TO_DATE -> stringResource(CoreR.string.reinstall) + else -> null + } + val actionColor = when (state) { + HomeViewModel.State.OUTDATED -> MiuixTheme.colorScheme.primary + else -> MiuixTheme.colorScheme.onSurfaceVariantActions + } + val hideRestoreIcon = if (isHidden) MiuixIcons.Show else MiuixIcons.Hide + + Card(modifier = modifier) { + Column(modifier = Modifier.fillMaxSize()) { + Box( + modifier = Modifier + .weight(1f) + .fillMaxWidth() + ) { + Column(modifier = Modifier.padding(16.dp)) { + Icon( + painter = painterResource(R.drawable.ic_manager), + contentDescription = null, + modifier = Modifier.size(24.dp), + tint = MiuixTheme.colorScheme.primary + ) + Spacer(Modifier.height(8.dp)) + Text( + text = stringResource(CoreR.string.home_app_title), + style = MiuixTheme.textStyles.headline2, + ) + Text( + text = version, + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + ) + if (progress in 1..99) { + Spacer(Modifier.height(8.dp)) + LinearProgressIndicator( + progress = progress / 100f, + modifier = Modifier.fillMaxWidth() + ) + } + } + Column( + modifier = Modifier.align(Alignment.TopEnd).padding(4.dp), + verticalArrangement = Arrangement.spacedBy(0.dp), + ) { + if (Info.env.isActive) { + IconButton(onClick = onHideRestorePressed) { + Icon( + imageVector = hideRestoreIcon, + contentDescription = null, + modifier = Modifier.size(18.dp), + tint = MiuixTheme.colorScheme.primary, + ) + } + } + if (remoteVersion != null) { + UpdateBadge( + version = remoteVersion, + modifier = Modifier.align(Alignment.End).padding(end = 4.dp) + ) + } + } + } + + if (actionLabel != null) { + HorizontalDivider(thickness = 0.75.dp) + Text( + text = actionLabel, + style = MiuixTheme.textStyles.body2, + color = actionColor, + textAlign = TextAlign.Center, + maxLines = 1, + modifier = Modifier + .fillMaxWidth() + .height(44.dp) + .clickable(onClick = onManagerPressed) + .padding(horizontal = 12.dp, vertical = 12.dp) + ) + } + } + } +} + +@Composable +private fun UpdateBadge(version: String, modifier: Modifier = Modifier) { + Text( + text = version, + color = MiuixTheme.colorScheme.onPrimary, + fontSize = 10.sp, + maxLines = 1, + modifier = modifier + .background(MiuixTheme.colorScheme.primary, RoundedCornerShape(6.dp)) + .padding(horizontal = 6.dp, vertical = 2.dp) + ) +} + +@Composable +private fun StatusCard() { + Card(modifier = Modifier.fillMaxWidth()) { + Row( + modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min), + ) { + Column( + modifier = Modifier.weight(1f).padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Text( + text = stringResource(CoreR.string.ramdisk), + style = MiuixTheme.textStyles.headline2, + ) + Text( + text = stringResource(if (Info.ramdisk) CoreR.string.yes else CoreR.string.no), + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + ) + } + VerticalDivider(thickness = 0.75.dp) + Column( + modifier = Modifier.weight(1f).padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Text( + text = stringResource(CoreR.string.zygisk), + style = MiuixTheme.textStyles.headline2, + ) + Text( + text = stringResource(if (Info.isZygiskEnabled) CoreR.string.yes else CoreR.string.no), + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + ) + } + VerticalDivider(thickness = 0.75.dp) + Column( + modifier = Modifier.weight(1f).padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Text( + text = stringResource(CoreR.string.denylist), + style = MiuixTheme.textStyles.headline2, + ) + Text( + text = stringResource(if (Config.denyList) CoreR.string.enabled else CoreR.string.disabled), + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + ) + } + } + } +} + +@Composable +private fun SupportBottomSheet( + show: MutableState, + onLinkClicked: (String) -> Unit, +) { + SuperBottomSheet( + show = show, + onDismissRequest = { show.value = false }, + title = stringResource(CoreR.string.home_support_title), + ) { + Column(modifier = Modifier.padding(bottom = 16.dp)) { + Text( + text = stringResource(CoreR.string.home_support_content), + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp) + ) + SuperArrow( + title = stringResource(CoreR.string.patreon), + onClick = { + show.value = false + onLinkClicked(Const.Url.PATREON_URL) + }, + startAction = { + Icon( + painter = painterResource(CoreR.drawable.ic_patreon), + contentDescription = null, + modifier = Modifier.size(24.dp), + tint = MiuixTheme.colorScheme.onSurfaceVariantActions + ) + } + ) + SuperArrow( + title = stringResource(CoreR.string.paypal), + onClick = { + show.value = false + onLinkClicked("https://paypal.me/magiskdonate") + }, + startAction = { + Icon( + painter = painterResource(CoreR.drawable.ic_paypal), + contentDescription = null, + modifier = Modifier.size(24.dp), + tint = MiuixTheme.colorScheme.onSurfaceVariantActions + ) + } + ) + } + } +} + +private data class LinkInfo(val label: String, val icon: Int, val url: String) +private data class DeveloperInfo(val name: String, val links: List) + +private val developers = listOf( + DeveloperInfo("topjohnwu", listOf( + LinkInfo("Twitter", CoreR.drawable.ic_twitter, "https://twitter.com/topjohnwu"), + LinkInfo("GitHub", CoreR.drawable.ic_github, Const.Url.SOURCE_CODE_URL), + )), + DeveloperInfo("vvb2060", listOf( + LinkInfo("Twitter", CoreR.drawable.ic_twitter, "https://twitter.com/vvb2060"), + LinkInfo("GitHub", CoreR.drawable.ic_github, "https://github.com/vvb2060"), + )), + DeveloperInfo("yujincheng08", listOf( + LinkInfo("Twitter", CoreR.drawable.ic_twitter, "https://twitter.com/shanasaimoe"), + LinkInfo("GitHub", CoreR.drawable.ic_github, "https://github.com/yujincheng08"), + LinkInfo("Sponsor", CoreR.drawable.ic_favorite, "https://github.com/sponsors/yujincheng08"), + )), + DeveloperInfo("rikkawww", listOf( + LinkInfo("Twitter", CoreR.drawable.ic_twitter, "https://twitter.com/rikkawww"), + LinkInfo("GitHub", CoreR.drawable.ic_github, "https://github.com/rikkawww"), + )), + DeveloperInfo("canyie", listOf( + LinkInfo("Twitter", CoreR.drawable.ic_twitter, "https://twitter.com/canyie2977"), + LinkInfo("GitHub", CoreR.drawable.ic_github, "https://github.com/canyie"), + )), +) + +@Composable +private fun DevelopersCard(onLinkClicked: (String) -> Unit) { + var selectedDev by remember { mutableStateOf(null) } + val showSheet = rememberSaveable { mutableStateOf(false) } + + Card(modifier = Modifier.fillMaxWidth()) { + developers.forEach { dev -> + SuperArrow( + title = "@${dev.name}", + onClick = { + selectedDev = dev + showSheet.value = true + } + ) + } + } + + val currentDev = selectedDev + if (currentDev != null) { + SuperBottomSheet( + show = showSheet, + onDismissRequest = { + showSheet.value = false + selectedDev = null + }, + title = "@${currentDev.name}", + ) { + Column(modifier = Modifier.padding(bottom = 16.dp)) { + currentDev.links.forEach { link -> + SuperArrow( + title = link.label, + onClick = { + showSheet.value = false + onLinkClicked(link.url) + selectedDev = null + }, + startAction = { + Icon( + painter = painterResource(link.icon), + contentDescription = null, + modifier = Modifier.size(24.dp), + tint = MiuixTheme.colorScheme.onSurfaceVariantActions + ) + } + ) + } + } + } + } +} + +private fun openLink(context: Context, url: String) { + try { + context.startActivity(Intent(Intent.ACTION_VIEW, url.toUri()).apply { + addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + }) + } catch (_: ActivityNotFoundException) { } +} + +@Composable +private fun InstallBottomSheet( + show: MutableState, + installVm: InstallViewModel, + installUiState: InstallViewModel.UiState, +) { + SuperBottomSheet( + show = show, + onDismissRequest = { show.value = false }, + title = stringResource(CoreR.string.install), + ) { + Column(modifier = Modifier.padding(bottom = 16.dp)) { + if (installUiState.notes.isNotEmpty()) { + Box(modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) { + MarkdownText(installUiState.notes) + } + HorizontalDivider(thickness = 0.75.dp) + } + + if (!installVm.skipOptions) { + InstallOptionsSection(installUiState, installVm) + } + + SuperArrow( + title = stringResource(CoreR.string.select_patch_file), + summary = stringResource(CoreR.string.select_patch_file_summary), + onClick = { + show.value = false + installVm.selectMethod(InstallViewModel.Method.PATCH) + }, + enabled = installUiState.step >= 1 || installVm.skipOptions + ) + + if (installVm.isRooted) { + SuperArrow( + title = stringResource(CoreR.string.direct_install), + summary = stringResource(CoreR.string.direct_install_summary), + onClick = { + show.value = false + installVm.selectMethod(InstallViewModel.Method.DIRECT) + installVm.install() + }, + enabled = installUiState.step >= 1 || installVm.skipOptions + ) + } + + if (!installVm.noSecondSlot) { + SuperArrow( + title = stringResource(CoreR.string.install_inactive_slot), + summary = stringResource(CoreR.string.install_inactive_slot_summary), + onClick = { + show.value = false + installVm.selectMethod(InstallViewModel.Method.INACTIVE_SLOT) + }, + enabled = installUiState.step >= 1 || installVm.skipOptions + ) + } + } + } +} + +@Composable +private fun InstallOptionsSection( + uiState: InstallViewModel.UiState, + viewModel: InstallViewModel +) { + Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = stringResource(CoreR.string.install_options_title), + style = MiuixTheme.textStyles.headline2, + ) + if (uiState.step == 0) { + TextButton( + text = stringResource(CoreR.string.install_next), + onClick = { viewModel.nextStep() } + ) + } + } + + if (uiState.step == 0) { + Spacer(Modifier.height(8.dp)) + if (!Info.isSAR) { + CheckboxRow( + label = stringResource(CoreR.string.keep_dm_verity), + checked = Config.keepVerity, + onCheckedChange = { Config.keepVerity = it } + ) + } + if (Info.isFDE) { + CheckboxRow( + label = stringResource(CoreR.string.keep_force_encryption), + checked = Config.keepEnc, + onCheckedChange = { Config.keepEnc = it } + ) + } + if (!Info.ramdisk) { + CheckboxRow( + label = stringResource(CoreR.string.recovery_mode), + checked = Config.recovery, + onCheckedChange = { Config.recovery = it } + ) + } + } + } +} + +@Composable +private fun CheckboxRow(label: String, checked: Boolean, onCheckedChange: (Boolean) -> Unit) { + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 4.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp) + ) { + Checkbox( + checked = checked, + onCheckedChange = { onCheckedChange(it) } + ) + Text( + text = label, + style = MiuixTheme.textStyles.body1, + ) + } +} + +@Composable +private fun UninstallComposableDialog( + showDialog: MutableState, + activity: MainActivity, + loadingDialog: LoadingDialogHandle, +) { + val scope = rememberCoroutineScope() + top.yukonga.miuix.kmp.extra.SuperDialog( + show = showDialog, + title = stringResource(CoreR.string.uninstall_magisk_title), + onDismissRequest = { showDialog.value = false }, + ) { + Text( + text = stringResource(CoreR.string.uninstall_magisk_msg), + style = MiuixTheme.textStyles.body1, + color = MiuixTheme.colorScheme.onSurface, + ) + Spacer(Modifier.height(16.dp)) + Row(modifier = Modifier.fillMaxWidth()) { + TextButton( + text = stringResource(CoreR.string.restore_img), + onClick = { + showDialog.value = false + scope.launch { + val success = loadingDialog.withLoading { + MagiskInstaller.Restore().exec() + } + activity.toast( + if (success) CoreR.string.restore_done else CoreR.string.restore_fail, + Toast.LENGTH_SHORT + ) + } + }, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = stringResource(CoreR.string.complete_uninstall), + onClick = { + showDialog.value = false + val intent = Intent(activity, activity.javaClass).apply { + action = FlashUtils.INTENT_FLASH + putExtra(FlashUtils.EXTRA_FLASH_ACTION, Const.Value.UNINSTALL) + flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP + } + activity.startActivity(intent) + }, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } +} + +@Composable +private fun ManagerInstallComposableDialog( + showDialog: MutableState, + activity: MainActivity, +) { + top.yukonga.miuix.kmp.extra.SuperDialog( + show = showDialog, + title = stringResource(CoreR.string.install), + onDismissRequest = { showDialog.value = false }, + ) { + MarkdownTextAsync { + val text = Info.update.note + java.io.File(activity.cacheDir, "${Info.update.versionCode}.md").writeText(text) + text + } + Spacer(Modifier.height(16.dp)) + Row(modifier = Modifier.fillMaxWidth()) { + TextButton( + text = stringResource(android.R.string.cancel), + onClick = { showDialog.value = false }, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = stringResource(CoreR.string.install), + onClick = { + showDialog.value = false + DownloadEngine.startWithActivity(activity, Subject.App()) + }, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } +} + +@Composable +private fun EnvFixComposableDialog( + showDialog: MutableState, + code: Int, + activity: MainActivity, + loadingDialog: LoadingDialogHandle, + onNavigateInstall: () -> Unit, +) { + val scope = rememberCoroutineScope() + val needsFullFix = code == 2 || + Info.env.versionCode != com.topjohnwu.magisk.core.BuildConfig.APP_VERSION_CODE || + Info.env.versionString != com.topjohnwu.magisk.core.BuildConfig.APP_VERSION_NAME + + top.yukonga.miuix.kmp.extra.SuperDialog( + show = showDialog, + title = stringResource(CoreR.string.env_fix_title), + onDismissRequest = { showDialog.value = false }, + ) { + Text( + text = stringResource( + if (needsFullFix) CoreR.string.env_full_fix_msg else CoreR.string.env_fix_msg + ), + style = MiuixTheme.textStyles.body1, + color = MiuixTheme.colorScheme.onSurface, + ) + Spacer(Modifier.height(16.dp)) + Row(modifier = Modifier.fillMaxWidth()) { + TextButton( + text = stringResource(android.R.string.cancel), + onClick = { showDialog.value = false }, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = stringResource(android.R.string.ok), + onClick = { + showDialog.value = false + if (needsFullFix) { + onNavigateInstall() + } else { + scope.launch { + val success = loadingDialog.withLoading { + MagiskInstaller.FixEnv().exec() + } + activity.toast( + if (success) CoreR.string.reboot_delay_toast else CoreR.string.setup_fail, + Toast.LENGTH_LONG + ) + if (success) { + @Suppress("DEPRECATION") + android.os.Handler(android.os.Looper.getMainLooper()) + .postDelayed({ reboot() }, 5000) + } + } + } + }, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } +} + +@Composable +private fun HideAppDialog(onDismiss: () -> Unit, onConfirm: (String) -> Unit) { + val showState = rememberSaveable { mutableStateOf(true) } + var appName by rememberSaveable { mutableStateOf("Settings") } + val isError = appName.length > AppMigration.MAX_LABEL_LENGTH || appName.isBlank() + + top.yukonga.miuix.kmp.extra.SuperDialog( + show = showState, + title = stringResource(CoreR.string.settings_hide_app_title), + onDismissRequest = onDismiss, + insideMargin = DpSize(24.dp, 24.dp) + ) { + Column(modifier = Modifier.padding(top = 8.dp)) { + top.yukonga.miuix.kmp.basic.TextField( + value = appName, + onValueChange = { appName = it }, + modifier = Modifier.fillMaxWidth(), + label = stringResource(CoreR.string.settings_app_name_hint), + ) + Spacer(Modifier.height(16.dp)) + Row(horizontalArrangement = Arrangement.SpaceBetween) { + TextButton( + text = stringResource(android.R.string.cancel), + onClick = onDismiss, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = stringResource(android.R.string.ok), + onClick = { if (!isError) onConfirm(appName) }, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } + } +} + +@Composable +private fun RestoreAppDialog(onDismiss: () -> Unit, onConfirm: () -> Unit) { + val showState = rememberSaveable { mutableStateOf(true) } + + top.yukonga.miuix.kmp.extra.SuperDialog( + show = showState, + title = stringResource(CoreR.string.settings_restore_app_title), + onDismissRequest = onDismiss, + insideMargin = DpSize(24.dp, 24.dp) + ) { + Column(modifier = Modifier.padding(top = 8.dp)) { + Text( + text = stringResource(CoreR.string.restore_app_confirmation), + style = MiuixTheme.textStyles.body1, + color = MiuixTheme.colorScheme.onSurface, + ) + Spacer(Modifier.height(16.dp)) + Row(horizontalArrangement = Arrangement.SpaceBetween) { + TextButton( + text = stringResource(android.R.string.cancel), + onClick = onDismiss, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = stringResource(android.R.string.ok), + onClick = onConfirm, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/home/HomeViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/home/HomeViewModel.kt new file mode 100644 index 000000000..61a004c9f --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/home/HomeViewModel.kt @@ -0,0 +1,163 @@ +package com.topjohnwu.magisk.ui.home + +import android.content.ActivityNotFoundException +import android.content.Intent +import android.widget.Toast +import androidx.core.net.toUri +import com.topjohnwu.magisk.arch.AsyncLoadViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.BuildConfig +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.download.Subject +import com.topjohnwu.magisk.core.download.Subject.App +import com.topjohnwu.magisk.core.ktx.await +import com.topjohnwu.magisk.core.ktx.toast +import com.topjohnwu.magisk.core.repository.NetworkService +import com.topjohnwu.superuser.Shell +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import kotlin.math.roundToInt +import com.topjohnwu.magisk.core.R as CoreR + +class HomeViewModel( + private val svc: NetworkService +) : AsyncLoadViewModel() { + + enum class State { + LOADING, INVALID, OUTDATED, UP_TO_DATE + } + + data class UiState( + val isNoticeVisible: Boolean = Config.safetyNotice, + val appState: State = State.LOADING, + val managerRemoteVersion: String = "", + val managerProgress: Int = 0, + val showUninstall: Boolean = false, + val showManagerInstall: Boolean = false, + val showHideRestore: Boolean = false, + val envFixCode: Int = 0, + ) + + private val _uiState = MutableStateFlow(UiState()) + val uiState: StateFlow = _uiState.asStateFlow() + + val magiskState + get() = when { + Info.isRooted && Info.env.isUnsupported -> State.OUTDATED + !Info.env.isActive -> State.INVALID + Info.env.versionCode < BuildConfig.APP_VERSION_CODE -> State.OUTDATED + else -> State.UP_TO_DATE + } + + val magiskInstalledVersion: String + get() = Info.env.run { + if (isActive) + "$versionString ($versionCode)" + if (isDebug) " (D)" else "" + else + "" + } + + val managerInstalledVersion: String + get() = "${BuildConfig.APP_VERSION_NAME} (${BuildConfig.APP_VERSION_CODE})" + + if (BuildConfig.DEBUG) " (D)" else "" + + companion object { + private var checkedEnv = false + } + + override suspend fun doLoadWork() { + _uiState.update { it.copy(appState = State.LOADING) } + Info.fetchUpdate(svc)?.apply { + val isDebug = Config.updateChannel == Config.Value.DEBUG_CHANNEL + _uiState.update { + it.copy( + appState = if (BuildConfig.APP_VERSION_CODE < versionCode) State.OUTDATED else State.UP_TO_DATE, + managerRemoteVersion = "$version ($versionCode)" + if (isDebug) " (D)" else "" + ) + } + } ?: run { + _uiState.update { it.copy(appState = State.INVALID, managerRemoteVersion = "") } + } + ensureEnv() + } + + private val networkObserver: (Boolean) -> Unit = { startLoading() } + + init { + Info.isConnected.observeForever(networkObserver) + } + + override fun onCleared() { + super.onCleared() + Info.isConnected.removeObserver(networkObserver) + } + + fun onProgressUpdate(progress: Float, subject: Subject) { + if (subject is App) + _uiState.update { it.copy(managerProgress = progress.times(100f).roundToInt()) } + } + + fun resetProgress() { + _uiState.update { it.copy(managerProgress = 0) } + } + + fun onLinkPressed(link: String) { + val intent = Intent(Intent.ACTION_VIEW, link.toUri()) + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + try { + AppContext.startActivity(intent) + } catch (e: ActivityNotFoundException) { + AppContext.toast(CoreR.string.open_link_failed_toast, Toast.LENGTH_SHORT) + } + } + + fun onDeletePressed() { + _uiState.update { it.copy(showUninstall = true) } + } + + fun onUninstallConsumed() { + _uiState.update { it.copy(showUninstall = false) } + } + + fun onManagerPressed() { + when (_uiState.value.appState) { + State.LOADING -> showSnackbar(CoreR.string.loading) + State.INVALID -> showSnackbar(CoreR.string.no_connection) + else -> _uiState.update { it.copy(showManagerInstall = true) } + } + } + + fun onManagerInstallConsumed() { + _uiState.update { it.copy(showManagerInstall = false) } + } + + fun onHideRestorePressed() { + _uiState.update { it.copy(showHideRestore = true) } + } + + fun onHideRestoreConsumed() { + _uiState.update { it.copy(showHideRestore = false) } + } + + fun onEnvFixConsumed() { + _uiState.update { it.copy(envFixCode = 0) } + } + + fun hideNotice() { + Config.safetyNotice = false + _uiState.update { it.copy(isNoticeVisible = false) } + } + + private suspend fun ensureEnv() { + if (magiskState == State.INVALID || checkedEnv) return + val cmd = "env_check ${Info.env.versionString} ${Info.env.versionCode}" + val code = Shell.cmd(cmd).await().code + if (code != 0) { + _uiState.update { it.copy(envFixCode = code) } + } + checkedEnv = true + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/install/InstallViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/install/InstallViewModel.kt new file mode 100644 index 000000000..a714eed50 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/install/InstallViewModel.kt @@ -0,0 +1,127 @@ +package com.topjohnwu.magisk.ui.install + +import android.net.Uri +import android.widget.Toast +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.BaseViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.BuildConfig.APP_VERSION_CODE +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.ktx.toast +import com.topjohnwu.magisk.core.repository.NetworkService +import com.topjohnwu.magisk.ui.navigation.Route +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import timber.log.Timber +import java.io.File +import java.io.IOException +import com.topjohnwu.magisk.core.R as CoreR + +class InstallViewModel(svc: NetworkService) : BaseViewModel() { + + enum class Method { NONE, PATCH, DIRECT, INACTIVE_SLOT } + + data class UiState( + val step: Int = 0, + val method: Method = Method.NONE, + val notes: String = "", + val patchUri: Uri? = null, + val requestFilePicker: Boolean = false, + val showSecondSlotWarning: Boolean = false, + ) + + val isRooted get() = Info.isRooted + val skipOptions = Info.isEmulator || (Info.isSAR && !Info.isFDE && Info.ramdisk) + val noSecondSlot = !isRooted || !Info.isAB || Info.isEmulator + + private val _uiState = MutableStateFlow(UiState(step = if (skipOptions) 1 else 0)) + val uiState: StateFlow = _uiState.asStateFlow() + + init { + viewModelScope.launch(Dispatchers.IO) { + try { + val noteFile = File(AppContext.cacheDir, "${APP_VERSION_CODE}.md") + val noteText = when { + noteFile.exists() -> noteFile.readText() + else -> { + val note = svc.fetchUpdate(APP_VERSION_CODE)?.note.orEmpty() + if (note.isEmpty()) return@launch + noteFile.writeText(note) + note + } + } + withContext(Dispatchers.Main) { + _uiState.update { it.copy(notes = noteText) } + } + } catch (e: IOException) { + Timber.e(e) + } + } + } + + fun nextStep() { + _uiState.update { it.copy(step = 1) } + } + + fun selectMethod(method: Method) { + _uiState.update { it.copy(method = method) } + when (method) { + Method.PATCH -> { + AppContext.toast(CoreR.string.patch_file_msg, Toast.LENGTH_LONG) + _uiState.update { it.copy(requestFilePicker = true) } + } + Method.INACTIVE_SLOT -> { + _uiState.update { it.copy(showSecondSlotWarning = true) } + } + else -> {} + } + } + + fun onFilePickerConsumed() { + _uiState.update { it.copy(requestFilePicker = false) } + } + + fun onSecondSlotWarningConsumed() { + _uiState.update { it.copy(showSecondSlotWarning = false) } + } + + fun onPatchFileSelected(uri: Uri) { + _uiState.update { it.copy(patchUri = uri) } + if (_uiState.value.method == Method.PATCH) { + install() + } + } + + fun install() { + when (_uiState.value.method) { + Method.PATCH -> navigateTo(Route.Flash( + action = Const.Value.PATCH_FILE, + additionalData = _uiState.value.patchUri!!.toString() + )) + Method.DIRECT -> navigateTo(Route.Flash( + action = Const.Value.FLASH_MAGISK + )) + Method.INACTIVE_SLOT -> navigateTo(Route.Flash( + action = Const.Value.FLASH_INACTIVE_SLOT + )) + else -> error("Unknown method") + } + } + + val canInstall: Boolean + get() { + val state = _uiState.value + return when (state.method) { + Method.PATCH -> state.patchUri != null + Method.DIRECT, Method.INACTIVE_SLOT -> true + Method.NONE -> false + } + } + +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/LogScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/LogScreen.kt new file mode 100644 index 000000000..447e30d0f --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/LogScreen.kt @@ -0,0 +1,400 @@ +package com.topjohnwu.magisk.ui.log + +import androidx.compose.foundation.Image +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.input.nestedscroll.NestedScrollConnection +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.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.topjohnwu.magisk.core.ktx.timeDateFormat +import com.topjohnwu.magisk.core.ktx.toTime +import com.topjohnwu.magisk.core.model.su.SuLog +import com.topjohnwu.magisk.ui.util.rememberDrawablePainter +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.CircularProgressIndicator +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.IconButton +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.TabRow +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TopAppBar +import top.yukonga.miuix.kmp.icon.MiuixIcons +import top.yukonga.miuix.kmp.icon.extended.Delete +import top.yukonga.miuix.kmp.icon.extended.Download +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun LogScreen(viewModel: LogViewModel) { + val uiState by viewModel.uiState.collectAsState() + var selectedTab by rememberSaveable { mutableIntStateOf(0) } + val tabTitles = listOf( + stringResource(CoreR.string.superuser), + stringResource(CoreR.string.magisk) + ) + val scrollBehavior = MiuixScrollBehavior() + + Scaffold( + topBar = { + TopAppBar( + title = stringResource(CoreR.string.logs), + actions = { + if (selectedTab == 1) { + IconButton(onClick = { viewModel.saveMagiskLog() }) { + Icon( + imageVector = MiuixIcons.Download, + contentDescription = stringResource(CoreR.string.save_log), + ) + } + } + IconButton( + modifier = Modifier.padding(end = 16.dp), + onClick = { + if (selectedTab == 0) viewModel.clearLog() + else viewModel.clearMagiskLog() + } + ) { + Icon( + imageVector = MiuixIcons.Delete, + contentDescription = stringResource(CoreR.string.clear_log), + ) + } + }, + scrollBehavior = scrollBehavior + ) + }, + popupHost = { } + ) { padding -> + Column(modifier = Modifier + .fillMaxSize() + .padding(padding) + ) { + TabRow( + tabs = tabTitles, + selectedTabIndex = selectedTab, + onTabSelected = { selectedTab = it }, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 12.dp, vertical = 8.dp) + ) + + if (uiState.loading) { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center + ) { + CircularProgressIndicator() + } + } else { + when (selectedTab) { + 0 -> SuLogTab( + logs = uiState.suLogs, + nestedScrollConnection = scrollBehavior.nestedScrollConnection + ) + 1 -> MagiskLogTab( + entries = uiState.magiskLogEntries, + nestedScrollConnection = scrollBehavior.nestedScrollConnection + ) + } + } + } + } +} + +@Composable +private fun SuLogTab(logs: List, nestedScrollConnection: NestedScrollConnection) { + Column(modifier = Modifier.fillMaxSize()) { + if (logs.isEmpty()) { + Box( + modifier = Modifier + .weight(1f) + .fillMaxWidth() + .padding(horizontal = 12.dp), + contentAlignment = Alignment.Center + ) { + Text( + text = stringResource(CoreR.string.log_data_none), + style = MiuixTheme.textStyles.body1, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + textAlign = TextAlign.Center, + ) + } + } else { + LazyColumn( + modifier = Modifier + .weight(1f) + .nestedScroll(nestedScrollConnection) + .padding(horizontal = 12.dp), + contentPadding = PaddingValues(top = 8.dp, bottom = 88.dp), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + items(logs, key = { it.id }) { log -> + SuLogCard(log) + } + } + } + } +} + +@Composable +private fun SuLogCard(log: SuLog) { + val res = LocalContext.current.resources + val pm = LocalContext.current.packageManager + val icon = remember(log.packageName) { + runCatching { + pm.getApplicationInfo(log.packageName, 0).loadIcon(pm) + }.getOrDefault(pm.defaultActivityIcon) + } + val allowed = log.action >= 2 + + val uidPidText = buildString { + append("UID: ${log.toUid} PID: ${log.fromPid}") + if (log.target != -1) { + val target = if (log.target == 0) "magiskd" else log.target.toString() + append(" → $target") + } + } + + val details = buildString { + if (log.context.isNotEmpty()) { + append(res.getString(CoreR.string.selinux_context, log.context)) + } + if (log.gids.isNotEmpty()) { + if (isNotEmpty()) append("\n") + append(res.getString(CoreR.string.supp_group, log.gids)) + } + if (log.command.isNotEmpty()) { + if (isNotEmpty()) append("\n") + append(log.command) + } + } + + Card(modifier = Modifier.fillMaxWidth()) { + Column(modifier = Modifier.padding(12.dp)) { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.Top + ) { + Image( + painter = rememberDrawablePainter(icon), + contentDescription = log.appName, + modifier = Modifier.size(36.dp) + ) + Spacer(Modifier.width(10.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + text = log.appName, + style = MiuixTheme.textStyles.body1, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + Text( + text = uidPidText, + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + Spacer(Modifier.width(8.dp)) + Column(horizontalAlignment = Alignment.End) { + Text( + text = log.time.toTime(timeDateFormat), + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + maxLines = 1, + ) + Spacer(Modifier.height(4.dp)) + SuActionBadge(allowed) + } + } + + if (details.isNotEmpty()) { + Spacer(Modifier.height(6.dp)) + Text( + text = details, + fontFamily = FontFamily.Monospace, + fontSize = 12.sp, + lineHeight = 16.sp, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + ) + } + } + } +} + +@Composable +private fun SuActionBadge(allowed: Boolean) { + val bg = if (allowed) MiuixTheme.colorScheme.primary else MiuixTheme.colorScheme.error + val fg = if (allowed) MiuixTheme.colorScheme.onPrimary else MiuixTheme.colorScheme.onError + val text = if (allowed) "Approved" else "Rejected" + Text( + text = text, + color = fg, + fontSize = 10.sp, + maxLines = 1, + modifier = Modifier + .background(bg, RoundedCornerShape(6.dp)) + .padding(horizontal = 6.dp, vertical = 2.dp) + ) +} + +@Composable +private fun MagiskLogTab( + entries: List, + nestedScrollConnection: NestedScrollConnection +) { + Column(modifier = Modifier.fillMaxSize()) { + if (entries.isEmpty()) { + Box( + modifier = Modifier + .weight(1f) + .fillMaxWidth() + .padding(horizontal = 12.dp), + contentAlignment = Alignment.Center + ) { + Text( + text = stringResource(CoreR.string.log_data_magisk_none), + style = MiuixTheme.textStyles.body1, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + textAlign = TextAlign.Center, + ) + } + } else { + val listState = rememberLazyListState(initialFirstVisibleItemIndex = entries.size - 1) + LazyColumn( + state = listState, + modifier = Modifier + .weight(1f) + .nestedScroll(nestedScrollConnection) + .padding(horizontal = 12.dp), + contentPadding = PaddingValues(top = 8.dp, bottom = 88.dp), + verticalArrangement = Arrangement.spacedBy(4.dp) + ) { + items(entries.size, key = { it }) { index -> + MagiskLogCard(entries[index]) + } + } + } + } +} + +@Composable +private fun MagiskLogCard(entry: MagiskLogEntry) { + var expanded by remember { mutableStateOf(false) } + + Card( + modifier = Modifier + .fillMaxWidth() + .clickable { expanded = !expanded } + ) { + Column(modifier = Modifier.padding(12.dp)) { + if (entry.isParsed) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(6.dp), + modifier = Modifier.weight(1f) + ) { + LogLevelBadge(entry.level) + Text( + text = entry.tag, + style = MiuixTheme.textStyles.body1, + fontWeight = FontWeight.Normal, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + Spacer(Modifier.width(8.dp)) + Text( + text = entry.timestamp, + fontSize = 11.sp, + fontFamily = FontFamily.Monospace, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + maxLines = 1, + ) + } + Spacer(Modifier.height(4.dp)) + } + + Text( + text = entry.message, + fontFamily = FontFamily.Monospace, + fontSize = 12.sp, + lineHeight = 16.sp, + color = MiuixTheme.colorScheme.onSurface, + maxLines = if (expanded) Int.MAX_VALUE else 3, + overflow = TextOverflow.Ellipsis, + ) + } + } +} + +@Composable +private fun LogLevelBadge(level: Char) { + val (bg, fg) = when (level) { + 'V' -> Color(0xFF9E9E9E) to Color.White + 'D' -> Color(0xFF2196F3) to Color.White + 'I' -> Color(0xFF4CAF50) to Color.White + 'W' -> Color(0xFFFFC107) to Color.Black + 'E' -> Color(0xFFF44336) to Color.White + 'F' -> Color(0xFF9C27B0) to Color.White + else -> Color(0xFF757575) to Color.White + } + Box( + modifier = Modifier + .clip(RoundedCornerShape(4.dp)) + .background(bg) + .padding(horizontal = 5.dp, vertical = 1.dp), + contentAlignment = Alignment.Center + ) { + Text( + text = level.toString(), + fontSize = 10.sp, + fontWeight = FontWeight.Bold, + fontFamily = FontFamily.Monospace, + color = fg, + ) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/LogViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/LogViewModel.kt new file mode 100644 index 000000000..96eaf3411 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/LogViewModel.kt @@ -0,0 +1,110 @@ +package com.topjohnwu.magisk.ui.log + +import android.system.Os +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.AsyncLoadViewModel +import com.topjohnwu.magisk.core.BuildConfig +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.R +import com.topjohnwu.magisk.core.ktx.timeFormatStandard +import com.topjohnwu.magisk.core.ktx.toTime +import com.topjohnwu.magisk.core.model.su.SuLog +import com.topjohnwu.magisk.core.repository.LogRepository +import com.topjohnwu.magisk.core.su.SuEvents +import com.topjohnwu.magisk.core.utils.MediaStoreUtils +import com.topjohnwu.magisk.core.utils.MediaStoreUtils.outputStream +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.debounce +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import java.io.FileInputStream + +class LogViewModel( + private val repo: LogRepository +) : AsyncLoadViewModel() { + + init { + @OptIn(kotlinx.coroutines.FlowPreview::class) + viewModelScope.launch { + SuEvents.logUpdated.debounce(500).collect { reload() } + } + } + + data class UiState( + val loading: Boolean = true, + val magiskLog: String = "", + val magiskLogEntries: List = emptyList(), + val suLogs: List = emptyList(), + ) + + private val _uiState = MutableStateFlow(UiState()) + val uiState: StateFlow = _uiState.asStateFlow() + + private var magiskLogRaw = "" + + override suspend fun doLoadWork() { + _uiState.update { it.copy(loading = true) } + withContext(Dispatchers.Default) { + magiskLogRaw = repo.fetchMagiskLogs() + val suLogs = repo.fetchSuLogs() + val entries = MagiskLogParser.parse(magiskLogRaw) + _uiState.update { it.copy( + loading = false, + magiskLog = magiskLogRaw, + magiskLogEntries = entries, + suLogs = suLogs, + ) } + } + } + + fun saveMagiskLog() { + viewModelScope.launch(Dispatchers.IO) { + val filename = "magisk_log_%s.log".format( + System.currentTimeMillis().toTime(timeFormatStandard)) + val logFile = MediaStoreUtils.getFile(filename) + logFile.uri.outputStream().bufferedWriter().use { file -> + file.write("---Detected Device Info---\n\n") + file.write("isAB=${Info.isAB}\n") + file.write("isSAR=${Info.isSAR}\n") + file.write("ramdisk=${Info.ramdisk}\n") + val uname = Os.uname() + file.write("kernel=${uname.sysname} ${uname.machine} ${uname.release} ${uname.version}\n") + + file.write("\n\n---System Properties---\n\n") + ProcessBuilder("getprop").start() + .inputStream.reader().use { it.copyTo(file) } + + file.write("\n\n---Environment Variables---\n\n") + System.getenv().forEach { (key, value) -> file.write("${key}=${value}\n") } + + file.write("\n\n---System MountInfo---\n\n") + FileInputStream("/proc/self/mountinfo").reader().use { it.copyTo(file) } + + file.write("\n---Magisk Logs---\n") + file.write("${Info.env.versionString} (${Info.env.versionCode})\n\n") + if (Info.env.isActive) file.write(magiskLogRaw) + + file.write("\n---Manager Logs---\n") + file.write("${BuildConfig.APP_VERSION_NAME} (${BuildConfig.APP_VERSION_CODE})\n\n") + ProcessBuilder("logcat", "-d").start() + .inputStream.reader().use { it.copyTo(file) } + } + showSnackbar(logFile.toString()) + } + } + + fun clearMagiskLog() = repo.clearMagiskLogs { + showSnackbar(R.string.logs_cleared) + startLoading() + } + + fun clearLog() = viewModelScope.launch { + repo.clearLogs() + showSnackbar(R.string.logs_cleared) + startLoading() + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/MagiskLogParser.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/MagiskLogParser.kt new file mode 100644 index 000000000..3c8b3b90c --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/log/MagiskLogParser.kt @@ -0,0 +1,56 @@ +package com.topjohnwu.magisk.ui.log + +data class MagiskLogEntry( + val timestamp: String = "", + val pid: Int = 0, + val tid: Int = 0, + val level: Char = 'I', + val tag: String = "", + val message: String = "", + val isParsed: Boolean = false, +) + +object MagiskLogParser { + + // Logcat format: "MM-DD HH:MM:SS.mmm PID TID LEVEL TAG : message" + private val logcatRegex = Regex( + """(\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d{3})\s+(\d+)\s+(\d+)\s+([VDIWEF])\s+(.+?)\s*:\s+(.*)""" + ) + + fun parse(raw: String): List { + if (raw.isBlank()) return emptyList() + + val lines = raw.lines() + val result = mutableListOf() + + for (line in lines) { + if (line.isBlank()) continue + + val match = logcatRegex.find(line) + if (match != null) { + result.add( + MagiskLogEntry( + timestamp = match.groupValues[1], + pid = match.groupValues[2].toIntOrNull() ?: 0, + tid = match.groupValues[3].toIntOrNull() ?: 0, + level = match.groupValues[4].firstOrNull() ?: 'I', + tag = match.groupValues[5].trim(), + message = match.groupValues[6], + isParsed = true, + ) + ) + } else if (result.isNotEmpty() && result.last().isParsed) { + // Continuation line — append to previous entry + val prev = result.last() + result[result.lastIndex] = prev.copy( + message = prev.message + "\n" + line.trimEnd() + ) + } else { + result.add( + MagiskLogEntry(message = line.trimEnd()) + ) + } + } + return result + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ActionScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ActionScreen.kt new file mode 100644 index 000000000..8c3941505 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ActionScreen.kt @@ -0,0 +1,72 @@ +package com.topjohnwu.magisk.ui.module + +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.padding +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.topjohnwu.magisk.R +import com.topjohnwu.magisk.ui.terminal.TerminalScreen +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.IconButton +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.SmallTopAppBar +import top.yukonga.miuix.kmp.icon.MiuixIcons +import top.yukonga.miuix.kmp.icon.extended.Back +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun ActionScreen(viewModel: ActionViewModel, actionName: String, onBack: () -> Unit) { + val actionState by viewModel.actionState.collectAsState() + val finished = actionState != ActionViewModel.State.RUNNING + + val scrollBehavior = MiuixScrollBehavior() + Scaffold( + topBar = { + SmallTopAppBar( + title = actionName, + navigationIcon = { + IconButton( + modifier = Modifier.padding(start = 16.dp), + onClick = onBack + ) { + Icon( + imageVector = MiuixIcons.Back, + contentDescription = null, + tint = MiuixTheme.colorScheme.onBackground + ) + } + }, + actions = { + if (finished) { + IconButton( + modifier = Modifier.padding(end = 16.dp), + onClick = { viewModel.saveLog() } + ) { + Icon( + painter = painterResource(R.drawable.ic_save_md2), + contentDescription = stringResource(CoreR.string.menuSaveLog), + tint = MiuixTheme.colorScheme.onBackground + ) + } + } + }, + scrollBehavior = scrollBehavior + ) + }, + popupHost = { } + ) { padding -> + TerminalScreen( + modifier = Modifier + .fillMaxSize() + .padding(padding), + onEmulatorCreated = { viewModel.onEmulatorCreated(it) }, + ) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ActionViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ActionViewModel.kt new file mode 100644 index 000000000..efd0bbf90 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ActionViewModel.kt @@ -0,0 +1,70 @@ +package com.topjohnwu.magisk.ui.module + +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.BaseViewModel +import com.topjohnwu.magisk.core.ktx.timeFormatStandard +import com.topjohnwu.magisk.core.ktx.toTime +import com.topjohnwu.magisk.core.utils.MediaStoreUtils +import com.topjohnwu.magisk.core.utils.MediaStoreUtils.outputStream +import com.topjohnwu.magisk.terminal.TerminalEmulator +import com.topjohnwu.magisk.terminal.runSuCommand +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +class ActionViewModel : BaseViewModel() { + + enum class State { + RUNNING, SUCCESS, FAILED + } + + private val _actionState = MutableStateFlow(State.RUNNING) + val actionState: StateFlow = _actionState.asStateFlow() + + var actionId: String = "" + var actionName: String = "" + + private var emulator: TerminalEmulator? = null + private val emulatorReady = CompletableDeferred() + + fun onEmulatorCreated(emu: TerminalEmulator) { + emulator = emu + emulatorReady.complete(emu) + } + + fun startRunAction() { + viewModelScope.launch { + val emu = emulatorReady.await() + + val success = withContext(Dispatchers.IO) { + runSuCommand( + emu, + "cd /data/adb/modules/$actionId && sh ./action.sh" + ) + } + + _actionState.value = if (success) State.SUCCESS else State.FAILED + } + } + + fun saveLog() { + viewModelScope.launch(Dispatchers.IO) { + val name = "%s_action_log_%s.log".format( + actionName, + System.currentTimeMillis().toTime(timeFormatStandard) + ) + val file = MediaStoreUtils.getFile(name) + file.uri.outputStream().bufferedWriter().use { writer -> + val transcript = emulator?.screen?.transcriptText + if (transcript != null) { + writer.write(transcript) + } + } + showSnackbar(file.toString()) + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ModuleScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ModuleScreen.kt new file mode 100644 index 000000000..92a884322 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ModuleScreen.kt @@ -0,0 +1,448 @@ +package com.topjohnwu.magisk.ui.module + +import android.net.Uri +import android.provider.OpenableColumns +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.animation.animateContentSize +import androidx.compose.animation.fadeIn +import androidx.compose.animation.fadeOut +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.runtime.Composable +import androidx.compose.runtime.MutableState +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.input.nestedscroll.nestedScroll +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextDecoration +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.di.ServiceLocator +import com.topjohnwu.magisk.core.download.DownloadEngine +import com.topjohnwu.magisk.core.model.module.OnlineModule +import com.topjohnwu.magisk.ui.MainActivity +import com.topjohnwu.magisk.ui.component.ConfirmResult +import com.topjohnwu.magisk.ui.component.MarkdownTextAsync +import com.topjohnwu.magisk.ui.component.rememberConfirmDialog +import kotlinx.coroutines.launch +import top.yukonga.miuix.kmp.basic.ButtonDefaults +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.CircularProgressIndicator +import top.yukonga.miuix.kmp.basic.FloatingActionButton +import top.yukonga.miuix.kmp.basic.HorizontalDivider +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.IconButton +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.Switch +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TextButton +import top.yukonga.miuix.kmp.basic.TopAppBar +import top.yukonga.miuix.kmp.extra.SuperDialog +import top.yukonga.miuix.kmp.icon.MiuixIcons +import top.yukonga.miuix.kmp.icon.extended.Add +import top.yukonga.miuix.kmp.icon.extended.Delete +import top.yukonga.miuix.kmp.icon.extended.Play +import top.yukonga.miuix.kmp.icon.extended.Undo +import top.yukonga.miuix.kmp.icon.extended.UploadCloud +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun ModuleScreen(viewModel: ModuleViewModel) { + val uiState by viewModel.uiState.collectAsState() + val scrollBehavior = MiuixScrollBehavior() + val colorScheme = MiuixTheme.colorScheme + val context = LocalContext.current + val scope = rememberCoroutineScope() + val activity = context as MainActivity + + var pendingZipUri by remember { mutableStateOf(null) } + var pendingZipName by remember { mutableStateOf("") } + val localInstallDialog = rememberConfirmDialog() + val confirmInstallTitle = stringResource(CoreR.string.confirm_install_title) + + var pendingOnlineModule by remember { mutableStateOf(null) } + val showOnlineDialog = rememberSaveable { mutableStateOf(false) } + + val filePicker = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri -> + if (uri != null) { + val displayName = context.contentResolver.query(uri, null, null, null, null)?.use { cursor -> + val idx = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME) + if (cursor.moveToFirst() && idx >= 0) cursor.getString(idx) else null + } ?: uri.lastPathSegment ?: "module.zip" + pendingZipUri = uri + pendingZipName = displayName + scope.launch { + val result = localInstallDialog.awaitConfirm( + title = confirmInstallTitle, + content = context.getString(CoreR.string.confirm_install, displayName), + ) + if (result == ConfirmResult.Confirmed) { + viewModel.confirmLocalInstall(uri) + } + pendingZipUri = null + } + } + } + + if (showOnlineDialog.value && pendingOnlineModule != null) { + OnlineModuleDialog( + item = pendingOnlineModule!!, + showDialog = showOnlineDialog, + onDownload = { install -> + showOnlineDialog.value = false + DownloadEngine.startWithActivity( + activity, + OnlineModuleSubject(pendingOnlineModule!!, install) + ) + pendingOnlineModule = null + }, + onDismiss = { + showOnlineDialog.value = false + pendingOnlineModule = null + } + ) + } + + Scaffold( + topBar = { + TopAppBar( + title = stringResource(CoreR.string.modules), + scrollBehavior = scrollBehavior + ) + }, + floatingActionButton = { + FloatingActionButton( + onClick = { filePicker.launch("application/zip") }, + shadowElevation = 0.dp, + modifier = Modifier + .padding(bottom = 88.dp, end = 20.dp) + .border(0.05.dp, colorScheme.outline.copy(alpha = 0.5f), CircleShape), + content = { + Icon( + imageVector = MiuixIcons.Add, + contentDescription = stringResource(CoreR.string.module_action_install_external), + modifier = Modifier.size(28.dp), + tint = colorScheme.onPrimary + ) + }, + ) + }, + popupHost = { } + ) { padding -> + if (uiState.loading) { + Box( + modifier = Modifier + .fillMaxSize() + .padding(padding), + contentAlignment = Alignment.Center + ) { + CircularProgressIndicator() + } + return@Scaffold + } + + if (uiState.modules.isEmpty()) { + Box( + modifier = Modifier + .fillMaxSize() + .padding(padding), + contentAlignment = Alignment.Center + ) { + Text( + text = stringResource(CoreR.string.module_empty), + style = MiuixTheme.textStyles.body1, + color = colorScheme.onSurfaceVariantSummary + ) + } + return@Scaffold + } + + LazyColumn( + modifier = Modifier + .fillMaxSize() + .nestedScroll(scrollBehavior.nestedScrollConnection) + .padding(padding) + .padding(horizontal = 12.dp), + contentPadding = PaddingValues(bottom = 160.dp), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + item { Spacer(Modifier.height(4.dp)) } + items(uiState.modules, key = { it.module.id }) { item -> + ModuleCard( + item = item, + viewModel = viewModel, + onUpdateClick = { onlineModule -> + if (onlineModule != null && Info.isConnected.value == true) { + pendingOnlineModule = onlineModule + showOnlineDialog.value = true + } + } + ) + } + item { Spacer(Modifier.height(4.dp)) } + } + } +} + +@Composable +private fun ModuleCard(item: ModuleItem, viewModel: ModuleViewModel, onUpdateClick: (OnlineModule?) -> Unit) { + val infoAlpha = if (!item.isRemoved && item.isEnabled && !item.showNotice) 1f else 0.5f + val strikeThrough = if (item.isRemoved) TextDecoration.LineThrough else TextDecoration.None + val colorScheme = MiuixTheme.colorScheme + val actionIconTint = colorScheme.onSurface.copy(alpha = 0.8f) + val actionBg = colorScheme.secondaryContainer.copy(alpha = 0.8f) + val updateBg = colorScheme.tertiaryContainer.copy(alpha = 0.6f) + val updateTint = colorScheme.onTertiaryContainer.copy(alpha = 0.8f) + val removeBg = colorScheme.errorContainer.copy(alpha = 0.6f) + val removeTint = colorScheme.onErrorContainer.copy(alpha = 0.8f) + var expanded by rememberSaveable(item.module.id) { mutableStateOf(false) } + val hasDescription = item.module.description.isNotBlank() + + Card( + modifier = Modifier.fillMaxWidth(), + insideMargin = PaddingValues(16.dp), + onClick = { if (hasDescription) expanded = !expanded } + ) { + Column(modifier = Modifier.alpha(infoAlpha)) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Column( + modifier = Modifier + .weight(1f) + .padding(end = 4.dp) + ) { + Text( + text = item.module.name, + style = MiuixTheme.textStyles.body1, + textDecoration = strikeThrough, + ) + Text( + text = stringResource( + CoreR.string.module_version_author, + item.module.version, + item.module.author + ), + style = MiuixTheme.textStyles.body2, + color = colorScheme.onSurfaceVariantSummary, + textDecoration = strikeThrough, + ) + } + Switch( + checked = item.isEnabled, + onCheckedChange = { viewModel.toggleEnabled(item) } + ) + } + + if (hasDescription) { + Box( + modifier = Modifier + .padding(top = 2.dp) + .animateContentSize() + ) { + Text( + text = item.module.description, + style = MiuixTheme.textStyles.body2, + color = colorScheme.onSurfaceVariantSummary, + textDecoration = strikeThrough, + overflow = if (expanded) TextOverflow.Clip else TextOverflow.Ellipsis, + maxLines = if (expanded) Int.MAX_VALUE else 4, + ) + } + } + + if (item.showNotice) { + Spacer(Modifier.height(4.dp)) + Text( + text = item.noticeText, + style = MiuixTheme.textStyles.body2, + color = colorScheme.primary, + ) + } + } + + HorizontalDivider( + modifier = Modifier.padding(vertical = 8.dp), + thickness = 0.5.dp, + color = colorScheme.outline.copy(alpha = 0.5f) + ) + + Row(verticalAlignment = Alignment.CenterVertically) { + AnimatedVisibility( + visible = item.isEnabled && !item.isRemoved, + enter = fadeIn(), + exit = fadeOut() + ) { + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + if (item.showAction) { + IconButton( + backgroundColor = actionBg, + minHeight = 35.dp, + minWidth = 35.dp, + onClick = { viewModel.runAction(item.module.id, item.module.name) }, + ) { + Row( + modifier = Modifier.padding(horizontal = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + Icon( + modifier = Modifier.size(20.dp), + imageVector = MiuixIcons.Play, + tint = actionIconTint, + contentDescription = stringResource(CoreR.string.module_action) + ) + Text( + text = stringResource(CoreR.string.module_action), + color = actionIconTint, + style = MiuixTheme.textStyles.body2, + ) + } + } + } + } + } + + Spacer(Modifier.weight(1f)) + + AnimatedVisibility( + visible = item.showUpdate && item.updateReady, + enter = fadeIn(), + exit = fadeOut() + ) { + IconButton( + modifier = Modifier.padding(end = 8.dp), + backgroundColor = updateBg, + minHeight = 35.dp, + minWidth = 35.dp, + onClick = { onUpdateClick(item.module.updateInfo) }, + ) { + Row( + modifier = Modifier.padding(horizontal = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + Icon( + modifier = Modifier.size(20.dp), + imageVector = MiuixIcons.UploadCloud, + tint = updateTint, + contentDescription = stringResource(CoreR.string.update), + ) + Text( + text = stringResource(CoreR.string.update), + color = updateTint, + style = MiuixTheme.textStyles.body2, + ) + } + } + } + + IconButton( + backgroundColor = if (item.isRemoved) actionBg else removeBg, + minHeight = 35.dp, + minWidth = 35.dp, + onClick = { viewModel.toggleRemove(item) }, + enabled = !item.isUpdated + ) { + val tint = if (item.isRemoved) actionIconTint else removeTint + Row( + modifier = Modifier.padding(horizontal = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + Icon( + modifier = Modifier.size(20.dp), + imageVector = if (item.isRemoved) MiuixIcons.Undo else MiuixIcons.Delete, + tint = tint, + contentDescription = null + ) + Text( + text = stringResource( + if (item.isRemoved) CoreR.string.module_state_restore + else CoreR.string.module_state_remove + ), + color = tint, + style = MiuixTheme.textStyles.body2, + ) + } + } + } + } +} + +@Composable +private fun OnlineModuleDialog( + item: OnlineModule, + showDialog: MutableState, + onDownload: (install: Boolean) -> Unit, + onDismiss: () -> Unit, +) { + val svc = ServiceLocator.networkService + val title = stringResource( + CoreR.string.repo_install_title, + item.name, item.version, item.versionCode + ) + + SuperDialog( + show = showDialog, + title = title, + onDismissRequest = onDismiss, + ) { + MarkdownTextAsync { + val str = svc.fetchString(item.changelog) + if (str.length > 1000) str.substring(0, 1000) else str + } + Spacer(Modifier.height(16.dp)) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.End, + verticalAlignment = Alignment.CenterVertically + ) { + TextButton( + text = stringResource(android.R.string.cancel), + onClick = onDismiss, + ) + Spacer(Modifier.weight(1f)) + TextButton( + text = stringResource(CoreR.string.download), + onClick = { onDownload(false) }, + ) + Spacer(Modifier.width(8.dp)) + TextButton( + text = stringResource(CoreR.string.install), + onClick = { onDownload(true) }, + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ModuleViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ModuleViewModel.kt new file mode 100644 index 000000000..c4facc338 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/module/ModuleViewModel.kt @@ -0,0 +1,125 @@ +package com.topjohnwu.magisk.ui.module + +import android.content.Context +import android.net.Uri +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import com.topjohnwu.magisk.arch.AsyncLoadViewModel +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.download.Subject +import com.topjohnwu.magisk.core.model.module.LocalModule +import com.topjohnwu.magisk.core.model.module.OnlineModule +import com.topjohnwu.magisk.ui.flash.FlashUtils +import com.topjohnwu.magisk.ui.navigation.Route +import com.topjohnwu.magisk.view.Notifications +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.withContext +import kotlinx.parcelize.Parcelize + +class ModuleItem(val module: LocalModule) { + val showNotice: Boolean + val showAction: Boolean + val noticeText: String + + init { + val isZygisk = module.isZygisk + val isRiru = module.isRiru + val zygiskUnloaded = isZygisk && module.zygiskUnloaded + + showNotice = zygiskUnloaded || + (Info.isZygiskEnabled && isRiru) || + (!Info.isZygiskEnabled && isZygisk) + showAction = module.hasAction && !showNotice + noticeText = when { + zygiskUnloaded -> "Zygisk module not loaded due to incompatibility" + isRiru -> "Module suspended because Zygisk is enabled" + else -> "Module suspended because Zygisk isn't enabled" + } + } + + var isEnabled by mutableStateOf(module.enable) + var isRemoved by mutableStateOf(module.remove) + var showUpdate by mutableStateOf(module.updateInfo != null) + val isUpdated = module.updated + val updateReady get() = module.outdated && !isRemoved && isEnabled +} + +@Parcelize +class OnlineModuleSubject( + override val module: OnlineModule, + override val autoLaunch: Boolean, + override val notifyId: Int = Notifications.nextId() +) : Subject.Module() { + override fun pendingIntent(context: Context) = FlashUtils.installIntent(context, file) +} + +class ModuleViewModel : AsyncLoadViewModel() { + + data class UiState( + val loading: Boolean = true, + val modules: List = emptyList(), + ) + + private val _uiState = MutableStateFlow(UiState()) + val uiState: StateFlow = _uiState.asStateFlow() + + override suspend fun doLoadWork() { + _uiState.update { it.copy(loading = true) } + val moduleLoaded = Info.env.isActive && + withContext(Dispatchers.IO) { LocalModule.loaded() } + if (moduleLoaded) { + val modules = withContext(Dispatchers.Default) { + LocalModule.installed().map { ModuleItem(it) } + } + _uiState.update { it.copy(loading = false, modules = modules) } + loadUpdateInfo() + } else { + _uiState.update { it.copy(loading = false) } + } + } + + private val networkObserver: (Boolean) -> Unit = { startLoading() } + + init { + Info.isConnected.observeForever(networkObserver) + } + + override fun onCleared() { + super.onCleared() + Info.isConnected.removeObserver(networkObserver) + } + + private suspend fun loadUpdateInfo() { + withContext(Dispatchers.IO) { + _uiState.value.modules.forEach { item -> + if (item.module.fetch()) { + item.showUpdate = item.module.updateInfo != null + } + } + } + } + + fun confirmLocalInstall(uri: Uri) { + navigateTo(Route.Flash(Const.Value.FLASH_ZIP, uri.toString())) + } + + fun runAction(id: String, name: String) { + navigateTo(Route.Action(id, name)) + } + + fun toggleEnabled(item: ModuleItem) { + item.isEnabled = !item.isEnabled + item.module.enable = item.isEnabled + } + + fun toggleRemove(item: ModuleItem) { + item.isRemoved = !item.isRemoved + item.module.remove = item.isRemoved + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/CollectNavEvents.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/CollectNavEvents.kt new file mode 100644 index 000000000..3441f6fb4 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/CollectNavEvents.kt @@ -0,0 +1,14 @@ +package com.topjohnwu.magisk.ui.navigation + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import com.topjohnwu.magisk.arch.BaseViewModel + +@Composable +fun CollectNavEvents(viewModel: BaseViewModel, navigator: Navigator) { + LaunchedEffect(viewModel) { + viewModel.navEvents.collect { route -> + navigator.push(route) + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/Navigator.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/Navigator.kt new file mode 100644 index 000000000..c2e424c01 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/Navigator.kt @@ -0,0 +1,72 @@ +package com.topjohnwu.magisk.ui.navigation + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.saveable.Saver +import androidx.compose.runtime.saveable.listSaver +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.snapshots.SnapshotStateList +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.navigation3.runtime.NavKey + +class Navigator(initialKey: NavKey) { + val backStack: SnapshotStateList = mutableStateListOf(initialKey) + + fun push(key: NavKey) { + backStack.add(key) + } + + fun replace(key: NavKey) { + if (backStack.isNotEmpty()) { + backStack[backStack.lastIndex] = key + } else { + backStack.add(key) + } + } + + fun replaceAll(keys: List) { + if (keys.isEmpty()) return + if (backStack.isNotEmpty()) { + backStack.clear() + backStack.addAll(keys) + } + } + + fun pop() { + backStack.removeLastOrNull() + } + + fun popUntil(predicate: (NavKey) -> Boolean) { + while (backStack.isNotEmpty() && !predicate(backStack.last())) { + backStack.removeAt(backStack.lastIndex) + } + } + + fun current(): NavKey? = backStack.lastOrNull() + + fun backStackSize(): Int = backStack.size + + companion object { + val Saver: Saver = listSaver( + save = { navigator -> navigator.backStack.toList() }, + restore = { savedList -> + val initialKey = savedList.firstOrNull() ?: Route.Main + Navigator(initialKey).also { + it.backStack.clear() + it.backStack.addAll(savedList) + } + } + ) + } +} + +@Composable +fun rememberNavigator(startRoute: NavKey): Navigator { + return rememberSaveable(startRoute, saver = Navigator.Saver) { + Navigator(startRoute) + } +} + +val LocalNavigator = staticCompositionLocalOf { + error("LocalNavigator not provided") +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/Routes.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/Routes.kt new file mode 100644 index 000000000..f05bcd033 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/navigation/Routes.kt @@ -0,0 +1,34 @@ +package com.topjohnwu.magisk.ui.navigation + +import android.os.Parcelable +import androidx.navigation3.runtime.NavKey +import kotlinx.parcelize.Parcelize +import kotlinx.serialization.Serializable + +sealed interface Route : NavKey, Parcelable { + @Parcelize + @Serializable + data object Main : Route + + @Parcelize + @Serializable + data object DenyList : Route + + @Parcelize + @Serializable + data class Flash( + val action: String, + val additionalData: String? = null, + ) : Route + + @Parcelize + @Serializable + data class SuperuserDetail(val uid: Int) : Route + + @Parcelize + @Serializable + data class Action( + val id: String, + val name: String, + ) : Route +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/settings/SettingsScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/settings/SettingsScreen.kt new file mode 100644 index 000000000..4bb346ee2 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/settings/SettingsScreen.kt @@ -0,0 +1,621 @@ +package com.topjohnwu.magisk.ui.settings + +import android.os.Build +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +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.unit.DpSize +import androidx.compose.ui.unit.dp +import androidx.core.content.pm.ShortcutManagerCompat +import com.topjohnwu.magisk.core.BuildConfig +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.Const +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.isRunningAsStub +import com.topjohnwu.magisk.core.tasks.AppMigration +import com.topjohnwu.magisk.core.utils.LocaleSetting +import com.topjohnwu.magisk.core.utils.MediaStoreUtils +import com.topjohnwu.magisk.ui.theme.ThemeState +import top.yukonga.miuix.kmp.basic.ButtonDefaults +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.SmallTitle +import top.yukonga.miuix.kmp.basic.TextButton +import top.yukonga.miuix.kmp.basic.TextField +import top.yukonga.miuix.kmp.basic.TopAppBar +import top.yukonga.miuix.kmp.extra.SuperArrow +import top.yukonga.miuix.kmp.extra.SuperDialog +import top.yukonga.miuix.kmp.extra.SuperDropdown +import top.yukonga.miuix.kmp.extra.SuperSwitch +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun SettingsScreen(viewModel: SettingsViewModel) { + val scrollBehavior = MiuixScrollBehavior() + Scaffold( + topBar = { + TopAppBar( + title = stringResource(CoreR.string.settings), + scrollBehavior = scrollBehavior + ) + }, + popupHost = { } + ) { padding -> + Column( + modifier = Modifier + .fillMaxSize() + .nestedScroll(scrollBehavior.nestedScrollConnection) + .verticalScroll(rememberScrollState()) + .padding(padding) + .padding(horizontal = 12.dp) + .padding(bottom = 88.dp) + ) { + CustomizationSection(viewModel) + Spacer(Modifier.height(12.dp)) + AppSettingsSection(viewModel) + if (Info.env.isActive) { + Spacer(Modifier.height(12.dp)) + MagiskSection(viewModel) + } + if (Info.showSuperUser) { + Spacer(Modifier.height(12.dp)) + SuperuserSection(viewModel) + } + } + } +} + +// --- Customization --- + +@Composable +private fun CustomizationSection(viewModel: SettingsViewModel) { + val context = LocalContext.current + + SmallTitle(text = stringResource(CoreR.string.settings_customization)) + Card(modifier = Modifier.fillMaxWidth()) { + if (LocaleSetting.useLocaleManager) { + val locale = LocaleSetting.instance.appLocale + val summary = locale?.getDisplayName(locale) ?: stringResource(CoreR.string.system_default) + SuperArrow( + title = stringResource(CoreR.string.language), + summary = summary, + onClick = { + context.startActivity(LocaleSetting.localeSettingsIntent) + } + ) + } else { + val names = remember { LocaleSetting.available.names } + val tags = remember { LocaleSetting.available.tags } + var selectedIndex by remember { + mutableIntStateOf(tags.indexOf(Config.locale).coerceAtLeast(0)) + } + SuperDropdown( + title = stringResource(CoreR.string.language), + items = names.toList(), + selectedIndex = selectedIndex, + onSelectedIndexChange = { index -> + selectedIndex = index + Config.locale = tags[index] + } + ) + } + + // Color Mode + val resources = context.resources + val colorModeEntries = remember { + resources.getStringArray(CoreR.array.color_mode).toList() + } + var colorMode by remember { mutableIntStateOf(Config.colorMode) } + SuperDropdown( + title = stringResource(CoreR.string.settings_color_mode), + items = colorModeEntries, + selectedIndex = colorMode, + onSelectedIndexChange = { index -> + colorMode = index + Config.colorMode = index + ThemeState.colorMode = index + } + ) + + if (isRunningAsStub && ShortcutManagerCompat.isRequestPinShortcutSupported(context)) { + SuperArrow( + title = stringResource(CoreR.string.add_shortcut_title), + summary = stringResource(CoreR.string.setting_add_shortcut_summary), + onClick = { viewModel.requestAddShortcut() } + ) + } + } +} + +// --- App Settings --- + +@Composable +private fun AppSettingsSection(viewModel: SettingsViewModel) { + val context = LocalContext.current + val resources = context.resources + val hidden = context.packageName != BuildConfig.APP_PACKAGE_NAME + + SmallTitle(text = stringResource(CoreR.string.home_app_title)) + Card(modifier = Modifier.fillMaxWidth()) { + // Update Channel + val updateChannelEntries = remember { + resources.getStringArray(CoreR.array.update_channel).toList() + } + var updateChannel by remember { + mutableIntStateOf(Config.updateChannel.coerceIn(0, updateChannelEntries.size - 1)) + } + var showUrlDialog by remember { mutableStateOf(false) } + + SuperDropdown( + title = stringResource(CoreR.string.settings_update_channel_title), + items = updateChannelEntries, + selectedIndex = updateChannel, + onSelectedIndexChange = { index -> + updateChannel = index + Config.updateChannel = index + Info.resetUpdate() + if (index == Config.Value.CUSTOM_CHANNEL && Config.customChannelUrl.isBlank()) { + showUrlDialog = true + } + } + ) + + // Update Channel URL (for custom channel) + if (updateChannel == Config.Value.CUSTOM_CHANNEL) { + UpdateChannelUrlDialog( + show = showUrlDialog, + onDismiss = { showUrlDialog = false } + ) + SuperArrow( + title = stringResource(CoreR.string.settings_update_custom), + summary = Config.customChannelUrl.ifBlank { null }, + onClick = { showUrlDialog = true } + ) + } + + // DoH Toggle + var doh by remember { mutableStateOf(Config.doh) } + SuperSwitch( + title = stringResource(CoreR.string.settings_doh_title), + summary = stringResource(CoreR.string.settings_doh_description), + checked = doh, + onCheckedChange = { + doh = it + Config.doh = it + } + ) + + // Update Checker + var checkUpdate by remember { mutableStateOf(Config.checkUpdate) } + SuperSwitch( + title = stringResource(CoreR.string.settings_check_update_title), + summary = stringResource(CoreR.string.settings_check_update_summary), + checked = checkUpdate, + onCheckedChange = { newValue -> + checkUpdate = newValue + Config.checkUpdate = newValue + } + ) + + // Download Path + var showDownloadDialog by remember { mutableStateOf(false) } + DownloadPathDialog( + show = showDownloadDialog, + onDismiss = { showDownloadDialog = false } + ) + SuperArrow( + title = stringResource(CoreR.string.settings_download_path_title), + summary = MediaStoreUtils.fullPath(Config.downloadDir), + onClick = { + showDownloadDialog = true + } + ) + + // Random Package Name + var randName by remember { mutableStateOf(Config.randName) } + SuperSwitch( + title = stringResource(CoreR.string.settings_random_name_title), + summary = stringResource(CoreR.string.settings_random_name_description), + checked = randName, + onCheckedChange = { + randName = it + Config.randName = it + } + ) + + } +} + +// --- Magisk --- + +@Composable +private fun MagiskSection(viewModel: SettingsViewModel) { + SmallTitle(text = stringResource(CoreR.string.magisk)) + Card(modifier = Modifier.fillMaxWidth()) { + // Systemless Hosts + SuperArrow( + title = stringResource(CoreR.string.settings_hosts_title), + summary = stringResource(CoreR.string.settings_hosts_summary), + onClick = { viewModel.createHosts() } + ) + + if (Const.Version.atLeast_24_0()) { + // Zygisk + var zygisk by remember { mutableStateOf(Config.zygisk) } + SuperSwitch( + title = stringResource(CoreR.string.zygisk), + summary = stringResource( + if (zygisk != Info.isZygiskEnabled) CoreR.string.reboot_apply_change + else CoreR.string.settings_zygisk_summary + ), + checked = zygisk, + onCheckedChange = { + zygisk = it + Config.zygisk = it + viewModel.notifyZygiskChange() + } + ) + + // DenyList + val denyListEnabled by viewModel.denyListEnabled.collectAsState() + SuperSwitch( + title = stringResource(CoreR.string.settings_denylist_title), + summary = stringResource(CoreR.string.settings_denylist_summary), + checked = denyListEnabled, + onCheckedChange = { viewModel.toggleDenyList(it) } + ) + + // DenyList Config + SuperArrow( + title = stringResource(CoreR.string.settings_denylist_config_title), + summary = stringResource(CoreR.string.settings_denylist_config_summary), + onClick = { viewModel.navigateToDenyList() } + ) + } + } +} + +// --- Superuser --- + +@Composable +private fun SuperuserSection(viewModel: SettingsViewModel) { + val context = LocalContext.current + val resources = context.resources + + SmallTitle(text = stringResource(CoreR.string.superuser)) + Card(modifier = Modifier.fillMaxWidth()) { + // Tapjack (SDK < S) + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { + var tapjack by remember { mutableStateOf(Config.suTapjack) } + SuperSwitch( + title = stringResource(CoreR.string.settings_su_tapjack_title), + summary = stringResource(CoreR.string.settings_su_tapjack_summary), + checked = tapjack, + onCheckedChange = { + tapjack = it + Config.suTapjack = it + } + ) + } + + // Authentication + var suAuth by remember { mutableStateOf(Config.suAuth) } + SuperSwitch( + title = stringResource(CoreR.string.settings_su_auth_title), + summary = stringResource( + if (Info.isDeviceSecure) CoreR.string.settings_su_auth_summary + else CoreR.string.settings_su_auth_insecure + ), + checked = suAuth, + enabled = Info.isDeviceSecure, + onCheckedChange = { newValue -> + viewModel.withAuth { + suAuth = newValue + Config.suAuth = newValue + } + } + ) + + // Access Mode + val accessEntries = remember { + resources.getStringArray(CoreR.array.su_access).toList() + } + var accessMode by remember { mutableIntStateOf(Config.rootMode) } + SuperDropdown( + title = stringResource(CoreR.string.superuser_access), + items = accessEntries, + selectedIndex = accessMode, + onSelectedIndexChange = { + accessMode = it + Config.rootMode = it + } + ) + + // Multiuser Mode + val multiuserEntries = remember { + resources.getStringArray(CoreR.array.multiuser_mode).toList() + } + val multiuserDescriptions = remember { + resources.getStringArray(CoreR.array.multiuser_summary).toList() + } + var multiuserMode by remember { mutableIntStateOf(Config.suMultiuserMode) } + SuperDropdown( + title = stringResource(CoreR.string.multiuser_mode), + summary = multiuserDescriptions.getOrElse(multiuserMode) { "" }, + items = multiuserEntries, + selectedIndex = multiuserMode, + enabled = Const.USER_ID == 0, + onSelectedIndexChange = { + multiuserMode = it + Config.suMultiuserMode = it + } + ) + + // Mount Namespace Mode + val namespaceEntries = remember { + resources.getStringArray(CoreR.array.namespace).toList() + } + val namespaceDescriptions = remember { + resources.getStringArray(CoreR.array.namespace_summary).toList() + } + var mntNamespaceMode by remember { mutableIntStateOf(Config.suMntNamespaceMode) } + SuperDropdown( + title = stringResource(CoreR.string.mount_namespace_mode), + summary = namespaceDescriptions.getOrElse(mntNamespaceMode) { "" }, + items = namespaceEntries, + selectedIndex = mntNamespaceMode, + onSelectedIndexChange = { + mntNamespaceMode = it + Config.suMntNamespaceMode = it + } + ) + + // Automatic Response + val autoResponseEntries = remember { + resources.getStringArray(CoreR.array.auto_response).toList() + } + var autoResponse by remember { mutableIntStateOf(Config.suAutoResponse) } + SuperDropdown( + title = stringResource(CoreR.string.auto_response), + items = autoResponseEntries, + selectedIndex = autoResponse, + onSelectedIndexChange = { newIndex -> + val doIt = { + autoResponse = newIndex + Config.suAutoResponse = newIndex + } + if (Config.suAuth) viewModel.withAuth(doIt) else doIt() + } + ) + + // Request Timeout + val timeoutEntries = remember { + resources.getStringArray(CoreR.array.request_timeout).toList() + } + val timeoutValues = remember { listOf(10, 15, 20, 30, 45, 60) } + var timeoutIndex by remember { + mutableIntStateOf(timeoutValues.indexOf(Config.suDefaultTimeout).coerceAtLeast(0)) + } + SuperDropdown( + title = stringResource(CoreR.string.request_timeout), + items = timeoutEntries, + selectedIndex = timeoutIndex, + onSelectedIndexChange = { + timeoutIndex = it + Config.suDefaultTimeout = timeoutValues[it] + } + ) + + // SU Notification + val notifEntries = remember { + resources.getStringArray(CoreR.array.su_notification).toList() + } + var suNotification by remember { mutableIntStateOf(Config.suNotification) } + SuperDropdown( + title = stringResource(CoreR.string.superuser_notification), + items = notifEntries, + selectedIndex = suNotification, + onSelectedIndexChange = { + suNotification = it + Config.suNotification = it + } + ) + + // Reauthenticate (SDK < O) + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { + var reAuth by remember { mutableStateOf(Config.suReAuth) } + SuperSwitch( + title = stringResource(CoreR.string.settings_su_reauth_title), + summary = stringResource(CoreR.string.settings_su_reauth_summary), + checked = reAuth, + onCheckedChange = { + reAuth = it + Config.suReAuth = it + } + ) + } + + // Restrict (version >= 30.1) + if (Const.Version.atLeast_30_1()) { + var restrict by remember { mutableStateOf(Config.suRestrict) } + SuperSwitch( + title = stringResource(CoreR.string.settings_su_restrict_title), + summary = stringResource(CoreR.string.settings_su_restrict_summary), + checked = restrict, + onCheckedChange = { + restrict = it + Config.suRestrict = it + } + ) + } + } +} + +// --- Dialogs --- + +@Composable +private fun UpdateChannelUrlDialog(show: Boolean, onDismiss: () -> Unit) { + val showState = rememberSaveable { mutableStateOf(show) } + showState.value = show + var url by rememberSaveable { mutableStateOf(Config.customChannelUrl) } + + SuperDialog( + show = showState, + onDismissRequest = onDismiss, + insideMargin = DpSize(24.dp, 24.dp) + ) { + Column(modifier = Modifier.padding(top = 8.dp)) { + TextField( + value = url, + onValueChange = { url = it }, + modifier = Modifier.fillMaxWidth(), + label = stringResource(CoreR.string.settings_update_custom_msg) + ) + Spacer(Modifier.height(16.dp)) + TextButton( + text = stringResource(android.R.string.ok), + onClick = { + Config.customChannelUrl = url + Info.resetUpdate() + onDismiss() + }, + modifier = Modifier.fillMaxWidth() + ) + } + } +} + +@Composable +private fun DownloadPathDialog(show: Boolean, onDismiss: () -> Unit) { + val showState = rememberSaveable { mutableStateOf(show) } + showState.value = show + var path by rememberSaveable { mutableStateOf(Config.downloadDir) } + + SuperDialog( + show = showState, + onDismissRequest = onDismiss, + insideMargin = DpSize(24.dp, 24.dp) + ) { + Column(modifier = Modifier.padding(top = 8.dp)) { + top.yukonga.miuix.kmp.basic.Text( + text = stringResource(CoreR.string.settings_download_path_message, MediaStoreUtils.fullPath(path)), + modifier = Modifier.padding(bottom = 8.dp) + ) + TextField( + value = path, + onValueChange = { path = it }, + modifier = Modifier.fillMaxWidth(), + label = stringResource(CoreR.string.settings_download_path_title) + ) + Spacer(Modifier.height(16.dp)) + TextButton( + text = stringResource(android.R.string.ok), + onClick = { + Config.downloadDir = path + onDismiss() + }, + modifier = Modifier.fillMaxWidth() + ) + } + } +} + +@Composable +private fun HideAppDialog(show: Boolean, onDismiss: () -> Unit, onConfirm: (String) -> Unit) { + val showState = rememberSaveable { mutableStateOf(show) } + showState.value = show + var appName by rememberSaveable { mutableStateOf("Settings") } + val isError = appName.length > AppMigration.MAX_LABEL_LENGTH || appName.isBlank() + + SuperDialog( + show = showState, + title = stringResource(CoreR.string.settings_hide_app_title), + onDismissRequest = onDismiss, + insideMargin = DpSize(24.dp, 24.dp) + ) { + Column(modifier = Modifier.padding(top = 8.dp)) { + TextField( + value = appName, + onValueChange = { appName = it }, + modifier = Modifier.fillMaxWidth(), + label = stringResource(CoreR.string.settings_app_name_hint), + ) + Spacer(Modifier.height(16.dp)) + Row( + horizontalArrangement = Arrangement.SpaceBetween, + ) { + TextButton( + text = stringResource(android.R.string.cancel), + onClick = onDismiss, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = stringResource(android.R.string.ok), + onClick = { if (!isError) onConfirm(appName) }, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } + } +} + +@Composable +private fun RestoreDialog(show: Boolean, onDismiss: () -> Unit, onConfirm: () -> Unit) { + val showState = rememberSaveable { mutableStateOf(show) } + showState.value = show + + SuperDialog( + show = showState, + title = stringResource(CoreR.string.settings_restore_app_title), + onDismissRequest = onDismiss, + insideMargin = DpSize(24.dp, 24.dp) + ) { + Column(modifier = Modifier.padding(top = 8.dp)) { + top.yukonga.miuix.kmp.basic.Text( + text = stringResource(CoreR.string.restore_app_confirmation), + color = MiuixTheme.colorScheme.onSurface, + ) + Spacer(Modifier.height(16.dp)) + Row( + horizontalArrangement = Arrangement.SpaceBetween, + ) { + TextButton( + text = stringResource(android.R.string.cancel), + onClick = onDismiss, + modifier = Modifier.weight(1f) + ) + Spacer(Modifier.width(20.dp)) + TextButton( + text = stringResource(android.R.string.ok), + onClick = onConfirm, + modifier = Modifier.weight(1f), + colors = ButtonDefaults.textButtonColorsPrimary() + ) + } + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/settings/SettingsViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/settings/SettingsViewModel.kt new file mode 100644 index 000000000..e5adb558c --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/settings/SettingsViewModel.kt @@ -0,0 +1,83 @@ +package com.topjohnwu.magisk.ui.settings + +import android.content.Context +import android.widget.Toast +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.BaseViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.R +import com.topjohnwu.magisk.core.ktx.toast +import com.topjohnwu.magisk.core.tasks.AppMigration +import com.topjohnwu.magisk.core.utils.RootUtils +import com.topjohnwu.magisk.ui.navigation.Route +import com.topjohnwu.magisk.view.Shortcuts +import com.topjohnwu.superuser.Shell +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +class SettingsViewModel : BaseViewModel() { + + private val _denyListEnabled = MutableStateFlow(Config.denyList) + val denyListEnabled: StateFlow = _denyListEnabled.asStateFlow() + + val zygiskMismatch get() = Config.zygisk != Info.isZygiskEnabled + + var authenticate: (onSuccess: () -> Unit) -> Unit = { it() } + + fun navigateToDenyList() { + navigateTo(Route.DenyList) + } + + fun requestAddShortcut() { + Shortcuts.addHomeIcon(AppContext) + } + + suspend fun hideApp(context: Context, name: String): Boolean { + val success = withContext(Dispatchers.IO) { + AppMigration.patchAndHide(context, name) + } + if (!success) { + context.toast(R.string.failure, Toast.LENGTH_LONG) + } + return success + } + + suspend fun restoreApp(context: Context): Boolean { + val success = AppMigration.restoreApp(context) + if (!success) { + context.toast(R.string.failure, Toast.LENGTH_LONG) + } + return success + } + + fun createHosts() { + viewModelScope.launch { + RootUtils.addSystemlessHosts() + AppContext.toast(R.string.settings_hosts_toast, Toast.LENGTH_SHORT) + } + } + + fun toggleDenyList(enabled: Boolean) { + _denyListEnabled.value = enabled + val cmd = if (enabled) "enable" else "disable" + Shell.cmd("magisk --denylist $cmd").submit { result -> + if (result.isSuccess) { + Config.denyList = enabled + } else { + _denyListEnabled.value = !enabled + } + } + } + + fun withAuth(action: () -> Unit) = authenticate(action) + + fun notifyZygiskChange() { + if (zygiskMismatch) showSnackbar(R.string.reboot_apply_change) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserDetailScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserDetailScreen.kt new file mode 100644 index 000000000..e1d33bd20 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserDetailScreen.kt @@ -0,0 +1,221 @@ +package com.topjohnwu.magisk.ui.superuser + +import androidx.compose.foundation.Image +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.input.nestedscroll.nestedScroll +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.topjohnwu.magisk.ui.component.ConfirmResult +import com.topjohnwu.magisk.ui.component.rememberConfirmDialog +import com.topjohnwu.magisk.ui.util.rememberDrawablePainter +import kotlinx.coroutines.launch +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.Icon +import top.yukonga.miuix.kmp.basic.IconButton +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.Switch +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TopAppBar +import top.yukonga.miuix.kmp.icon.MiuixIcons +import top.yukonga.miuix.kmp.icon.extended.Back +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun SuperuserDetailScreen( + uid: Int, + viewModel: SuperuserViewModel, + onBack: () -> Unit, +) { + val uiState by viewModel.uiState.collectAsState() + val items = uiState.policies.filter { it.policy.uid == uid } + val item = items.firstOrNull() + val scrollBehavior = MiuixScrollBehavior() + val scope = rememberCoroutineScope() + val revokeDialog = rememberConfirmDialog() + val revokeTitle = stringResource(CoreR.string.su_revoke_title) + val revokeMsg = item?.let { stringResource(CoreR.string.su_revoke_msg, it.appName) } ?: "" + + LaunchedEffect(Unit) { viewModel.refreshSuRestrict() } + + Scaffold( + topBar = { + TopAppBar( + title = stringResource(CoreR.string.superuser_setting), + navigationIcon = { + IconButton( + modifier = Modifier.padding(start = 16.dp), + onClick = onBack + ) { + Icon( + imageVector = MiuixIcons.Back, + contentDescription = stringResource(CoreR.string.back), + ) + } + }, + scrollBehavior = scrollBehavior + ) + }, + popupHost = { } + ) { padding -> + if (item == null) return@Scaffold + + LazyColumn( + modifier = Modifier + .fillMaxSize() + .nestedScroll(scrollBehavior.nestedScrollConnection) + .padding(padding) + .padding(horizontal = 12.dp), + contentPadding = PaddingValues(bottom = 88.dp), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + item { + Spacer(Modifier.height(4.dp)) + } + + item { + Card(modifier = Modifier.fillMaxWidth()) { + Row( + modifier = Modifier.padding(16.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Image( + painter = rememberDrawablePainter(item.icon), + contentDescription = item.appName, + modifier = Modifier.size(48.dp) + ) + Spacer(Modifier.width(16.dp)) + Column { + Row(verticalAlignment = Alignment.CenterVertically) { + Text( + text = item.title, + style = MiuixTheme.textStyles.headline2, + modifier = Modifier.weight(1f, fill = false), + ) + if (item.isSharedUid) { + Spacer(Modifier.width(6.dp)) + SharedUidBadge() + } + } + Text( + text = item.packageName, + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary + ) + Text( + text = "UID: ${item.policy.uid}", + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary + ) + } + } + } + } + + item { + Card(modifier = Modifier.fillMaxWidth()) { + Column { + if (uiState.suRestrict || item.isRestricted) { + SwitchRow( + title = stringResource(CoreR.string.settings_su_restrict_title), + checked = item.isRestricted, + onCheckedChange = { viewModel.toggleRestrict(item) } + ) + } + SwitchRow( + title = stringResource(CoreR.string.superuser_toggle_notification), + checked = item.notification, + onCheckedChange = { viewModel.updateNotify(item) } + ) + SwitchRow( + title = stringResource(CoreR.string.logs), + checked = item.logging, + onCheckedChange = { viewModel.updateLogging(item) } + ) + } + } + } + + item { + Card( + modifier = Modifier + .fillMaxWidth() + .clickable { + if (viewModel.requiresAuth) { + viewModel.authenticate { viewModel.performDelete(item, onBack) } + } else { + scope.launch { + val result = revokeDialog.awaitConfirm( + title = revokeTitle, + content = revokeMsg, + ) + if (result == ConfirmResult.Confirmed) { + viewModel.performDelete(item, onBack) + } + } + } + } + ) { + RevokeRow() + } + } + } + } +} + +@Composable +private fun SwitchRow( + title: String, + checked: Boolean, + onCheckedChange: () -> Unit, +) { + Row( + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 16.dp, vertical = 14.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = title, + style = MiuixTheme.textStyles.body1, + modifier = Modifier.weight(1f), + ) + Spacer(Modifier.width(16.dp)) + Switch( + checked = checked, + onCheckedChange = { onCheckedChange() } + ) + } +} + +@Composable +private fun RevokeRow() { + Text( + text = stringResource(CoreR.string.superuser_toggle_revoke), + style = MiuixTheme.textStyles.body1, + color = MiuixTheme.colorScheme.error, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 16.dp, vertical = 16.dp) + ) +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserScreen.kt new file mode 100644 index 000000000..9ccc497cd --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserScreen.kt @@ -0,0 +1,195 @@ +package com.topjohnwu.magisk.ui.superuser + +import androidx.compose.foundation.Image +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.IntrinsicSize +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.input.nestedscroll.nestedScroll +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.topjohnwu.magisk.ui.navigation.LocalNavigator +import com.topjohnwu.magisk.ui.navigation.Route +import com.topjohnwu.magisk.ui.util.rememberDrawablePainter +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.CircularProgressIndicator +import top.yukonga.miuix.kmp.basic.MiuixScrollBehavior +import top.yukonga.miuix.kmp.basic.Scaffold +import top.yukonga.miuix.kmp.basic.Switch +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TopAppBar +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@Composable +fun SuperuserScreen(viewModel: SuperuserViewModel) { + val uiState by viewModel.uiState.collectAsState() + val scrollBehavior = MiuixScrollBehavior() + val navigator = LocalNavigator.current + + Scaffold( + topBar = { + TopAppBar( + title = stringResource(CoreR.string.superuser), + scrollBehavior = scrollBehavior + ) + }, + popupHost = { } + ) { padding -> + if (uiState.loading) { + Box( + modifier = Modifier + .fillMaxSize() + .padding(padding), + contentAlignment = Alignment.Center + ) { + CircularProgressIndicator() + } + return@Scaffold + } + + if (uiState.policies.isEmpty()) { + Box( + modifier = Modifier + .fillMaxSize() + .padding(padding), + contentAlignment = Alignment.Center + ) { + Text( + text = stringResource(CoreR.string.superuser_policy_none), + style = MiuixTheme.textStyles.body1, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary + ) + } + return@Scaffold + } + + LazyColumn( + modifier = Modifier + .fillMaxSize() + .nestedScroll(scrollBehavior.nestedScrollConnection) + .padding(padding) + .padding(horizontal = 12.dp), + contentPadding = PaddingValues(bottom = 88.dp), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + item { Spacer(Modifier.height(4.dp)) } + items(uiState.policies, key = { "${it.policy.uid}_${it.packageName}" }) { item -> + PolicyCard( + item = item, + onToggle = { viewModel.togglePolicy(item) }, + onDetail = { navigator.push(Route.SuperuserDetail(item.policy.uid)) }, + ) + } + item { Spacer(Modifier.height(4.dp)) } + } + } +} + +@Composable +private fun PolicyCard( + item: PolicyItem, + onToggle: () -> Unit, + onDetail: () -> Unit, +) { + Card( + modifier = Modifier + .fillMaxWidth() + .alpha(if (item.isEnabled) 1f else 0.5f) + ) { + Row( + modifier = Modifier + .fillMaxWidth() + .height(IntrinsicSize.Min), + verticalAlignment = Alignment.CenterVertically + ) { + Row( + modifier = Modifier + .weight(1f) + .clickable(onClick = onDetail) + .padding(16.dp), + verticalAlignment = Alignment.CenterVertically + ) { + Image( + painter = rememberDrawablePainter(item.icon), + contentDescription = item.appName, + modifier = Modifier.size(40.dp) + ) + Spacer(Modifier.width(12.dp)) + Column(modifier = Modifier.weight(1f)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text( + text = item.title, + style = MiuixTheme.textStyles.body1, + modifier = Modifier.weight(1f, fill = false), + ) + if (item.isSharedUid) { + Spacer(Modifier.width(6.dp)) + SharedUidBadge() + } + } + Text( + text = item.packageName, + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary + ) + } + } + + Box( + modifier = Modifier + .fillMaxHeight() + .padding(vertical = 12.dp) + .width(0.5.dp) + .background(MiuixTheme.colorScheme.dividerLine) + ) + + Box( + modifier = Modifier + .clickable(onClick = onToggle) + .padding(horizontal = 20.dp, vertical = 16.dp), + contentAlignment = Alignment.Center + ) { + Switch( + checked = item.isEnabled, + onCheckedChange = { onToggle() } + ) + } + } + } +} + +@Composable +internal fun SharedUidBadge(modifier: Modifier = Modifier) { + Text( + text = "SharedUID", + color = MiuixTheme.colorScheme.onPrimary, + fontSize = 10.sp, + maxLines = 1, + modifier = modifier + .background(MiuixTheme.colorScheme.primary, RoundedCornerShape(6.dp)) + .padding(horizontal = 6.dp, vertical = 2.dp) + ) +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserViewModel.kt new file mode 100644 index 000000000..f62a31c15 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/superuser/SuperuserViewModel.kt @@ -0,0 +1,193 @@ +package com.topjohnwu.magisk.ui.superuser + +import android.annotation.SuppressLint +import android.content.pm.PackageManager +import android.content.pm.PackageManager.MATCH_UNINSTALLED_PACKAGES +import android.graphics.drawable.Drawable +import android.os.Process +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.AsyncLoadViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.Info +import com.topjohnwu.magisk.core.R +import com.topjohnwu.magisk.core.data.magiskdb.PolicyDao +import com.topjohnwu.magisk.core.ktx.getLabel +import com.topjohnwu.magisk.core.model.su.SuPolicy +import com.topjohnwu.magisk.core.su.SuEvents +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.debounce +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import java.util.Locale + +class PolicyItem( + val policy: SuPolicy, + val packageName: String, + val isSharedUid: Boolean, + val icon: Drawable, + val appName: String, +) { + val title get() = appName + val showSlider = Config.suRestrict || policy.policy == SuPolicy.RESTRICT + + var isExpanded by mutableStateOf(false) + var policyValue by mutableIntStateOf(policy.policy) + var notification by mutableStateOf(policy.notification) + var logging by mutableStateOf(policy.logging) + + val isEnabled get() = policyValue >= SuPolicy.ALLOW + val isRestricted get() = policyValue == SuPolicy.RESTRICT +} + +class SuperuserViewModel( + private val db: PolicyDao +) : AsyncLoadViewModel() { + + var authenticate: (onSuccess: () -> Unit) -> Unit = { it() } + + init { + @OptIn(kotlinx.coroutines.FlowPreview::class) + viewModelScope.launch { + SuEvents.policyChanged.debounce(500).collect { reload() } + } + } + + data class UiState( + val loading: Boolean = true, + val policies: List = emptyList(), + val suRestrict: Boolean = Config.suRestrict, + ) + + private val _uiState = MutableStateFlow(UiState()) + val uiState: StateFlow = _uiState.asStateFlow() + + @SuppressLint("InlinedApi") + override suspend fun doLoadWork() { + if (!Info.showSuperUser) { + _uiState.update { it.copy(loading = false) } + return + } + _uiState.update { it.copy(loading = true) } + withContext(Dispatchers.IO) { + db.deleteOutdated() + db.delete(AppContext.applicationInfo.uid) + val policies = ArrayList() + val pm = AppContext.packageManager + for (policy in db.fetchAll()) { + val pkgs = + if (policy.uid == Process.SYSTEM_UID) arrayOf("android") + else pm.getPackagesForUid(policy.uid) + if (pkgs == null) { + db.delete(policy.uid) + continue + } + val map = pkgs.mapNotNull { pkg -> + try { + val info = pm.getPackageInfo(pkg, MATCH_UNINSTALLED_PACKAGES) + PolicyItem( + policy = policy, + packageName = info.packageName, + isSharedUid = info.sharedUserId != null, + icon = info.applicationInfo?.loadIcon(pm) ?: pm.defaultActivityIcon, + appName = info.applicationInfo?.getLabel(pm) ?: info.packageName + ) + } catch (_: PackageManager.NameNotFoundException) { + null + } + } + if (map.isEmpty()) { + db.delete(policy.uid) + continue + } + policies.addAll(map) + } + policies.sortWith(compareBy( + { it.appName.lowercase(Locale.ROOT) }, + { it.packageName } + )) + _uiState.update { it.copy(loading = false, policies = policies, suRestrict = Config.suRestrict) } + } + } + + fun refreshSuRestrict() { + _uiState.update { it.copy(suRestrict = Config.suRestrict) } + } + + val requiresAuth get() = Config.suAuth + + fun performDelete(item: PolicyItem, onDeleted: () -> Unit = {}) { + viewModelScope.launch { + db.delete(item.policy.uid) + _uiState.update { state -> + state.copy(policies = state.policies.filter { it.policy.uid != item.policy.uid }) + } + onDeleted() + } + } + + fun updateNotify(item: PolicyItem) { + item.notification = !item.notification + item.policy.notification = item.notification + viewModelScope.launch { + db.update(item.policy) + _uiState.value.policies + .filter { it.policy.uid == item.policy.uid } + .forEach { it.notification = item.notification } + val res = if (item.notification) R.string.su_snack_notif_on else R.string.su_snack_notif_off + showSnackbar(AppContext.getString(res, item.appName)) + } + } + + fun updateLogging(item: PolicyItem) { + item.logging = !item.logging + item.policy.logging = item.logging + viewModelScope.launch { + db.update(item.policy) + _uiState.value.policies + .filter { it.policy.uid == item.policy.uid } + .forEach { it.logging = item.logging } + val res = if (item.logging) R.string.su_snack_log_on else R.string.su_snack_log_off + showSnackbar(AppContext.getString(res, item.appName)) + } + } + + fun updatePolicy(item: PolicyItem, newPolicy: Int) { + fun updateState() { + viewModelScope.launch { + item.policy.policy = newPolicy + item.policyValue = newPolicy + db.update(item.policy) + _uiState.value.policies + .filter { it.policy.uid == item.policy.uid } + .forEach { it.policyValue = newPolicy } + val res = if (newPolicy >= SuPolicy.ALLOW) R.string.su_snack_grant else R.string.su_snack_deny + showSnackbar(AppContext.getString(res, item.appName)) + } + } + + if (Config.suAuth) { + authenticate { updateState() } + } else { + updateState() + } + } + + fun togglePolicy(item: PolicyItem) { + val newPolicy = if (item.isEnabled) SuPolicy.DENY else SuPolicy.ALLOW + updatePolicy(item, newPolicy) + } + + fun toggleRestrict(item: PolicyItem) { + val newPolicy = if (item.isRestricted) SuPolicy.ALLOW else SuPolicy.RESTRICT + updatePolicy(item, newPolicy) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestActivity.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestActivity.kt new file mode 100644 index 000000000..3b0cc9e4d --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestActivity.kt @@ -0,0 +1,133 @@ +package com.topjohnwu.magisk.ui.surequest + +import android.content.Context +import android.content.Intent +import android.content.pm.ActivityInfo +import android.content.res.Resources +import android.os.Build +import android.os.Bundle +import android.view.View +import android.view.ViewGroup +import android.view.Window +import android.view.WindowManager +import android.view.accessibility.AccessibilityEvent +import android.view.accessibility.AccessibilityNodeInfo +import android.view.accessibility.AccessibilityNodeProvider +import androidx.activity.compose.setContent +import androidx.appcompat.app.AppCompatActivity +import androidx.appcompat.app.AppCompatDelegate +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.ui.Modifier +import androidx.lifecycle.ViewModelProvider +import androidx.lifecycle.lifecycleScope +import com.topjohnwu.magisk.R +import com.topjohnwu.magisk.arch.VMFactory +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.base.ActivityExtension +import com.topjohnwu.magisk.core.base.UntrackedActivity +import com.topjohnwu.magisk.core.su.SuCallbackHandler +import com.topjohnwu.magisk.core.su.SuCallbackHandler.REQUEST +import com.topjohnwu.magisk.core.wrap +import com.topjohnwu.magisk.ui.theme.MagiskTheme +import com.topjohnwu.magisk.ui.theme.Theme +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import top.yukonga.miuix.kmp.utils.MiuixPopupUtils.Companion.MiuixPopupHost + +open class SuRequestActivity : AppCompatActivity(), UntrackedActivity { + + private val extension = ActivityExtension(this) + private val viewModel: SuRequestViewModel by lazy { + ViewModelProvider(this, VMFactory)[SuRequestViewModel::class.java] + } + + init { + AppCompatDelegate.setDefaultNightMode(Config.darkTheme) + } + + override fun attachBaseContext(base: Context) { + super.attachBaseContext(base.wrap()) + } + + override fun onCreate(savedInstanceState: Bundle?) { + extension.onCreate(savedInstanceState) + supportRequestWindowFeature(Window.FEATURE_NO_TITLE) + requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LOCKED + window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + window.addFlags(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN) + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { + window.setHideOverlayWindows(true) + } + setTheme(Theme.selected.themeRes) + super.onCreate(savedInstanceState) + + viewModel.finishActivity = { finish() } + viewModel.authenticate = { onSuccess -> + extension.withAuthentication { if (it) onSuccess() } + } + + if (intent.action == Intent.ACTION_VIEW) { + val action = intent.getStringExtra("action") + if (action == REQUEST) { + viewModel.handleRequest(intent) + } else { + lifecycleScope.launch { + withContext(Dispatchers.IO) { + SuCallbackHandler.run(this@SuRequestActivity, action, intent.extras) + } + finish() + } + } + } else { + finish() + } + + if (viewModel.useTapjackProtection) { + window.decorView.rootView.accessibilityDelegate = EmptyAccessibilityDelegate + } + + setContent { + MagiskTheme { + Box(modifier = Modifier.fillMaxSize()) { + SuRequestScreen(viewModel = viewModel) + MiuixPopupHost() + } + } + } + } + + override fun onSaveInstanceState(outState: Bundle) { + super.onSaveInstanceState(outState) + extension.onSaveInstanceState(outState) + } + + override fun getTheme(): Resources.Theme { + val theme = super.getTheme() + theme.applyStyle(R.style.Foundation_Floating, true) + return theme + } + + @Deprecated("Use OnBackPressedDispatcher") + override fun onBackPressed() { + viewModel.denyPressed() + } + + override fun finish() { + super.finishAndRemoveTask() + } + + private object EmptyAccessibilityDelegate : View.AccessibilityDelegate() { + override fun sendAccessibilityEvent(host: View, eventType: Int) {} + override fun performAccessibilityAction(host: View, action: Int, args: Bundle?) = true + override fun sendAccessibilityEventUnchecked(host: View, event: AccessibilityEvent) {} + override fun dispatchPopulateAccessibilityEvent(host: View, event: AccessibilityEvent) = true + override fun onPopulateAccessibilityEvent(host: View, event: AccessibilityEvent) {} + override fun onInitializeAccessibilityEvent(host: View, event: AccessibilityEvent) {} + override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfo) {} + override fun addExtraDataToAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfo, extraDataKey: String, arguments: Bundle?) {} + override fun onRequestSendAccessibilityEvent(host: ViewGroup, child: View, event: AccessibilityEvent): Boolean = false + override fun getAccessibilityNodeProvider(host: View): AccessibilityNodeProvider? = null + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestScreen.kt new file mode 100644 index 000000000..61ae94f15 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestScreen.kt @@ -0,0 +1,208 @@ +package com.topjohnwu.magisk.ui.surequest + +import android.view.MotionEvent +import android.widget.Toast +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.widthIn +import androidx.compose.runtime.Composable +import androidx.compose.runtime.derivedStateOf +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.ExperimentalComposeUiApi +import androidx.compose.ui.Modifier +import androidx.compose.ui.input.pointer.pointerInteropFilter +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringArrayResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import com.topjohnwu.magisk.core.ktx.toast +import com.topjohnwu.magisk.ui.superuser.SharedUidBadge +import com.topjohnwu.magisk.ui.util.rememberDrawablePainter +import top.yukonga.miuix.kmp.basic.ButtonDefaults +import top.yukonga.miuix.kmp.basic.Card +import top.yukonga.miuix.kmp.basic.Slider +import top.yukonga.miuix.kmp.basic.SliderDefaults +import top.yukonga.miuix.kmp.basic.Text +import top.yukonga.miuix.kmp.basic.TextButton +import top.yukonga.miuix.kmp.theme.MiuixTheme +import com.topjohnwu.magisk.core.R as CoreR + +@OptIn(ExperimentalComposeUiApi::class) +@Composable +fun SuRequestScreen(viewModel: SuRequestViewModel) { + if (!viewModel.showUi) return + + val context = LocalContext.current + val icon = viewModel.icon + val title = viewModel.title + val packageName = viewModel.packageName + val grantEnabled = viewModel.grantEnabled + val denyCountdown = viewModel.denyCountdown + val selectedPosition = viewModel.selectedItemPosition + val timeoutEntries = stringArrayResource(CoreR.array.allow_timeout).toList() + // Slider order: Once(1), 10min(2), 20min(3), 30min(4), 60min(5), Forever(0) + val sliderToIndex = intArrayOf(1, 2, 3, 4, 5, 0) + val indexToSlider = remember { + IntArray(sliderToIndex.size).also { arr -> + sliderToIndex.forEachIndexed { slider, orig -> arr[orig] = slider } + } + } + val sliderValue = indexToSlider[selectedPosition].toFloat() + val sliderLabel by remember(sliderValue) { + derivedStateOf { timeoutEntries[sliderToIndex[sliderValue.toInt()]] } + } + + val denyText = if (denyCountdown > 0) { + "${stringResource(CoreR.string.deny)} ($denyCountdown)" + } else { + stringResource(CoreR.string.deny) + } + + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center + ) { + Card( + modifier = Modifier + .widthIn(min = 320.dp, max = 420.dp) + .padding(24.dp) + ) { + Column( + modifier = Modifier.padding(20.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.padding(horizontal = 8.dp) + ) { + if (icon != null) { + Image( + painter = rememberDrawablePainter(icon), + contentDescription = null, + modifier = Modifier.size(40.dp) + ) + Spacer(Modifier.width(12.dp)) + } + Column { + Row(verticalAlignment = Alignment.CenterVertically) { + Text( + text = title, + style = MiuixTheme.textStyles.body1, + fontWeight = FontWeight.Bold, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + modifier = Modifier.weight(1f, fill = false), + ) + if (viewModel.isSharedUid) { + Spacer(Modifier.width(6.dp)) + SharedUidBadge() + } + } + Text( + text = packageName, + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + } + + Spacer(Modifier.height(16.dp)) + + Text( + text = stringResource(CoreR.string.su_request_title), + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.primary, + fontWeight = FontWeight.Bold, + textAlign = TextAlign.Center, + ) + + Spacer(Modifier.height(16.dp)) + + Text( + text = "Permission timeout: $sliderLabel", + style = MiuixTheme.textStyles.body2, + color = MiuixTheme.colorScheme.onSurfaceVariantSummary, + modifier = Modifier.fillMaxWidth().padding(start = 8.dp), + ) + Spacer(Modifier.height(8.dp)) + Slider( + value = sliderValue, + onValueChange = { value -> + viewModel.spinnerTouched() + val pos = value.toInt().coerceIn(0, sliderToIndex.lastIndex) + viewModel.selectedItemPosition = sliderToIndex[pos] + }, + valueRange = 0f..5f, + steps = 4, + showKeyPoints = true, + height = 20.dp, + hapticEffect = SliderDefaults.SliderHapticEffect.Step, + modifier = Modifier.fillMaxWidth().padding(horizontal = 4.dp) + ) + Spacer(Modifier.height(16.dp)) + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp) + ) { + TextButton( + text = denyText, + onClick = { viewModel.denyPressed() }, + modifier = Modifier.weight(1f), + cornerRadius = 12.dp, + minHeight = 40.dp, + insideMargin = PaddingValues(horizontal = 16.dp, vertical = 8.dp), + ) + TextButton( + text = stringResource(CoreR.string.grant), + enabled = grantEnabled, + colors = ButtonDefaults.textButtonColorsPrimary(), + onClick = { viewModel.grantPressed() }, + cornerRadius = 12.dp, + minHeight = 40.dp, + insideMargin = PaddingValues(horizontal = 16.dp, vertical = 8.dp), + modifier = Modifier + .weight(1f) + .then( + if (viewModel.useTapjackProtection) { + Modifier.pointerInteropFilter { event -> + if (event.flags and MotionEvent.FLAG_WINDOW_IS_OBSCURED != 0 || + event.flags and MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED != 0 + ) { + if (event.action == MotionEvent.ACTION_UP) { + context.toast( + CoreR.string.touch_filtered_warning, + Toast.LENGTH_SHORT + ) + } + true + } else { + false + } + } + } else Modifier + ) + ) + } + } + } + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestViewModel.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestViewModel.kt new file mode 100644 index 000000000..897e142df --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/surequest/SuRequestViewModel.kt @@ -0,0 +1,134 @@ +package com.topjohnwu.magisk.ui.surequest + +import android.content.Intent +import android.content.SharedPreferences +import android.graphics.drawable.Drawable +import android.os.CountDownTimer +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.viewModelScope +import com.topjohnwu.magisk.arch.BaseViewModel +import com.topjohnwu.magisk.core.AppContext +import com.topjohnwu.magisk.core.Config +import com.topjohnwu.magisk.core.data.magiskdb.PolicyDao +import com.topjohnwu.magisk.core.ktx.getLabel +import com.topjohnwu.magisk.core.model.su.SuPolicy.Companion.ALLOW +import com.topjohnwu.magisk.core.model.su.SuPolicy.Companion.DENY +import com.topjohnwu.magisk.core.su.SuRequestHandler +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import java.util.concurrent.TimeUnit.SECONDS + +class SuRequestViewModel( + policyDB: PolicyDao, + private val timeoutPrefs: SharedPreferences +) : BaseViewModel() { + + var authenticate: (onSuccess: () -> Unit) -> Unit = { it() } + var finishActivity: () -> Unit = {} + + var icon by mutableStateOf(null) + var title by mutableStateOf("") + var packageName by mutableStateOf("") + var isSharedUid by mutableStateOf(false) + + var selectedItemPosition by mutableIntStateOf(0) + var grantEnabled by mutableStateOf(false) + var denyCountdown by mutableIntStateOf(0) + + var showUi by mutableStateOf(false) + var useTapjackProtection by mutableStateOf(false) + + private val handler = SuRequestHandler(AppContext.packageManager, policyDB) + private val millis = SECONDS.toMillis(Config.suDefaultTimeout.toLong()) + private var timer = SuTimer(millis, 1000) + private var initialized = false + + fun grantPressed() { + cancelTimer() + if (Config.suAuth) { + authenticate { respond(ALLOW) } + } else { + respond(ALLOW) + } + } + + fun denyPressed() { + respond(DENY) + } + + fun spinnerTouched() { + cancelTimer() + } + + fun handleRequest(intent: Intent) { + viewModelScope.launch(Dispatchers.Default) { + if (handler.start(intent)) + showDialog() + else + finishActivity() + } + } + + private fun showDialog() { + val pm = handler.pm + val info = handler.pkgInfo + val app = info.applicationInfo + + isSharedUid = info.sharedUserId != null + if (app == null) { + icon = pm.defaultActivityIcon + title = info.sharedUserId.toString() + packageName = info.sharedUserId.toString() + } else { + icon = app.loadIcon(pm) + title = app.getLabel(pm) + packageName = info.packageName + } + + selectedItemPosition = timeoutPrefs.getInt(packageName, 0) + timer.start() + useTapjackProtection = Config.suTapjack + showUi = true + initialized = true + } + + private fun respond(action: Int) { + if (!initialized) return + timer.cancel() + + val pos = selectedItemPosition + timeoutPrefs.edit().putInt(packageName, pos).apply() + + viewModelScope.launch { + handler.respond(action, Config.Value.TIMEOUT_LIST[pos]) + finishActivity() + } + } + + private fun cancelTimer() { + timer.cancel() + denyCountdown = 0 + } + + private inner class SuTimer( + private val millis: Long, + interval: Long + ) : CountDownTimer(millis, interval) { + + override fun onTick(remains: Long) { + if (!grantEnabled && remains <= millis - 1000) { + grantEnabled = true + } + denyCountdown = (remains / 1000).toInt() + 1 + } + + override fun onFinish() { + denyCountdown = 0 + respond(DENY) + } + } + +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/terminal/TerminalRenderer.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/terminal/TerminalRenderer.kt new file mode 100644 index 000000000..ecb8d8dba --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/terminal/TerminalRenderer.kt @@ -0,0 +1,281 @@ +package com.topjohnwu.magisk.ui.terminal + +import android.graphics.Canvas +import android.graphics.Paint +import android.graphics.PorterDuff +import android.graphics.Typeface +import com.topjohnwu.magisk.terminal.TerminalEmulator +import com.topjohnwu.magisk.terminal.TextStyle +import com.topjohnwu.magisk.terminal.WcWidth + +/** + * Renderer of a [TerminalEmulator] into a [Canvas]. + * + * Saves font metrics, so needs to be recreated each time the typeface or font size changes. + */ +class TerminalRenderer( + textSize: Int, + typeface: Typeface, +) { + val textSize: Int = textSize + val typeface: Typeface = typeface + private val textPaint = Paint() + + /** The width of a single mono spaced character obtained by [Paint.measureText] on a single 'X'. */ + val fontWidth: Float + + /** The [Paint.getFontSpacing]. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */ + val fontLineSpacing: Int + + /** The [Paint.ascent]. See http://www.fampennings.nl/maarten/android/08numgrid/font.png */ + private val fontAscent: Int + + /** The [fontLineSpacing] + [fontAscent]. */ + val fontLineSpacingAndAscent: Int + + private val asciiMeasures = FloatArray(127) + + init { + textPaint.typeface = typeface + textPaint.isAntiAlias = true + textPaint.textSize = textSize.toFloat() + + fontLineSpacing = kotlin.math.ceil(textPaint.fontSpacing).toInt() + fontAscent = kotlin.math.ceil(textPaint.ascent()).toInt() + fontLineSpacingAndAscent = fontLineSpacing + fontAscent + fontWidth = textPaint.measureText("X") + + val sb = StringBuilder(" ") + for (i in asciiMeasures.indices) { + sb[0] = i.toChar() + asciiMeasures[i] = textPaint.measureText(sb, 0, 1) + } + } + + /** + * Render the terminal to a canvas with at a specified row scroll, and an optional rectangular selection. + */ + fun render( + mEmulator: TerminalEmulator, + canvas: Canvas, + topRow: Int, + selectionY1: Int, + selectionY2: Int, + selectionX1: Int, + selectionX2: Int, + ) { + val reverseVideo = mEmulator.isReverseVideo + val endRow = topRow + mEmulator.mRows + val columns = mEmulator.mColumns + val cursorCol = mEmulator.cursorCol + val cursorRow = mEmulator.cursorRow + val cursorVisible = mEmulator.shouldCursorBeVisible() + val screen = mEmulator.screen + val palette = mEmulator.mColors.currentColors + val cursorShape = mEmulator.cursorStyle + + if (reverseVideo) { + canvas.drawColor(palette[TextStyle.COLOR_INDEX_FOREGROUND], PorterDuff.Mode.SRC) + } + + var heightOffset = fontLineSpacingAndAscent.toFloat() + for (row in topRow until endRow) { + heightOffset += fontLineSpacing + + val cursorX = if (row == cursorRow && cursorVisible) cursorCol else -1 + var selx1 = -1 + var selx2 = -1 + if (row in selectionY1..selectionY2) { + if (row == selectionY1) selx1 = selectionX1 + selx2 = if (row == selectionY2) selectionX2 else mEmulator.mColumns + } + + val lineObject = screen.allocateFullLineIfNecessary(screen.externalToInternalRow(row)) + val line = lineObject.text + val charsUsedInLine = lineObject.spaceUsed + + var lastRunStyle = 0L + var lastRunInsideCursor = false + var lastRunInsideSelection = false + var lastRunStartColumn = -1 + var lastRunStartIndex = 0 + var lastRunFontWidthMismatch = false + var currentCharIndex = 0 + var measuredWidthForRun = 0f + + var column = 0 + while (column < columns) { + val charAtIndex = line[currentCharIndex] + val charIsHighsurrogate = Character.isHighSurrogate(charAtIndex) + val charsForCodePoint = if (charIsHighsurrogate) 2 else 1 + val codePoint = if (charIsHighsurrogate) { + Character.toCodePoint(charAtIndex, line[currentCharIndex + 1]) + } else { + charAtIndex.code + } + val codePointWcWidth = WcWidth.width(codePoint) + val insideCursor = cursorX == column || (codePointWcWidth == 2 && cursorX == column + 1) + val insideSelection = column >= selx1 && column <= selx2 + val style = lineObject.getStyle(column) + + // Check if the measured text width for this code point is not the same as that expected by wcwidth(). + // This could happen for some fonts which are not truly monospace, or for more exotic characters such as + // smileys which android font renders as wide. + // If this is detected, we draw this code point scaled to match what wcwidth() expects. + val measuredCodePointWidth = if (codePoint < asciiMeasures.size) { + asciiMeasures[codePoint] + } else { + textPaint.measureText(line, currentCharIndex, charsForCodePoint) + } + val fontWidthMismatch = kotlin.math.abs(measuredCodePointWidth / fontWidth - codePointWcWidth.toFloat()) > 0.01f + + if (style != lastRunStyle || insideCursor != lastRunInsideCursor || insideSelection != lastRunInsideSelection || + fontWidthMismatch || lastRunFontWidthMismatch + ) { + if (column != 0) { + val columnWidthSinceLastRun = column - lastRunStartColumn + val charsSinceLastRun = currentCharIndex - lastRunStartIndex + val cursorColor = if (lastRunInsideCursor) mEmulator.mColors.currentColors[TextStyle.COLOR_INDEX_CURSOR] else 0 + var invertCursorTextColor = false + if (lastRunInsideCursor && cursorShape == TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK) { + invertCursorTextColor = true + } + drawTextRun( + canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, + lastRunStartIndex, charsSinceLastRun, measuredWidthForRun, + cursorColor, cursorShape, lastRunStyle, + reverseVideo || invertCursorTextColor || lastRunInsideSelection, + ) + } + measuredWidthForRun = 0f + lastRunStyle = style + lastRunInsideCursor = insideCursor + lastRunInsideSelection = insideSelection + lastRunStartColumn = column + lastRunStartIndex = currentCharIndex + lastRunFontWidthMismatch = fontWidthMismatch + } + measuredWidthForRun += measuredCodePointWidth + column += codePointWcWidth + currentCharIndex += charsForCodePoint + while (currentCharIndex < charsUsedInLine && WcWidth.width(line, currentCharIndex) <= 0) { + // Eat combining chars so that they are treated as part of the last non-combining code point, + // instead of e.g. being considered inside the cursor in the next run. + currentCharIndex += if (Character.isHighSurrogate(line[currentCharIndex])) 2 else 1 + } + } + + val columnWidthSinceLastRun = columns - lastRunStartColumn + val charsSinceLastRun = currentCharIndex - lastRunStartIndex + val cursorColor = if (lastRunInsideCursor) mEmulator.mColors.currentColors[TextStyle.COLOR_INDEX_CURSOR] else 0 + var invertCursorTextColor = false + if (lastRunInsideCursor && cursorShape == TerminalEmulator.TERMINAL_CURSOR_STYLE_BLOCK) { + invertCursorTextColor = true + } + drawTextRun( + canvas, line, palette, heightOffset, lastRunStartColumn, columnWidthSinceLastRun, + lastRunStartIndex, charsSinceLastRun, measuredWidthForRun, + cursorColor, cursorShape, lastRunStyle, + reverseVideo || invertCursorTextColor || lastRunInsideSelection, + ) + } + } + + private fun drawTextRun( + canvas: Canvas, + text: CharArray, + palette: IntArray, + y: Float, + startColumn: Int, + runWidthColumns: Int, + startCharIndex: Int, + runWidthChars: Int, + mes: Float, + cursor: Int, + cursorStyle: Int, + textStyle: Long, + reverseVideo: Boolean, + ) { + var foreColor = TextStyle.decodeForeColor(textStyle) + val effect = TextStyle.decodeEffect(textStyle) + var backColor = TextStyle.decodeBackColor(textStyle) + val bold = (effect and (TextStyle.CHARACTER_ATTRIBUTE_BOLD or TextStyle.CHARACTER_ATTRIBUTE_BLINK)) != 0 + val underline = (effect and TextStyle.CHARACTER_ATTRIBUTE_UNDERLINE) != 0 + val italic = (effect and TextStyle.CHARACTER_ATTRIBUTE_ITALIC) != 0 + val strikeThrough = (effect and TextStyle.CHARACTER_ATTRIBUTE_STRIKETHROUGH) != 0 + val dim = (effect and TextStyle.CHARACTER_ATTRIBUTE_DIM) != 0 + + if ((foreColor and 0xff000000.toInt()) != 0xff000000.toInt()) { + // Let bold have bright colors if applicable (one of the first 8): + if (bold && foreColor in 0..7) foreColor += 8 + foreColor = palette[foreColor] + } + + if ((backColor and 0xff000000.toInt()) != 0xff000000.toInt()) { + backColor = palette[backColor] + } + + // Reverse video here if _one and only one_ of the reverse flags are set: + val reverseVideoHere = reverseVideo xor ((effect and TextStyle.CHARACTER_ATTRIBUTE_INVERSE) != 0) + if (reverseVideoHere) { + val tmp = foreColor + foreColor = backColor + backColor = tmp + } + + var left = startColumn * fontWidth + var right = left + runWidthColumns * fontWidth + + var adjustedMes = mes / fontWidth + var savedMatrix = false + if (kotlin.math.abs(adjustedMes - runWidthColumns) > 0.01) { + canvas.save() + canvas.scale(runWidthColumns / adjustedMes, 1f) + left *= adjustedMes / runWidthColumns + right *= adjustedMes / runWidthColumns + savedMatrix = true + } + + if (backColor != palette[TextStyle.COLOR_INDEX_BACKGROUND]) { + // Only draw non-default background. + textPaint.color = backColor + canvas.drawRect(left, y - fontLineSpacingAndAscent + fontAscent, right, y, textPaint) + } + + if (cursor != 0) { + textPaint.color = cursor + var cursorHeight = (fontLineSpacingAndAscent - fontAscent).toFloat() + if (cursorStyle == TerminalEmulator.TERMINAL_CURSOR_STYLE_UNDERLINE) cursorHeight /= 4f + else if (cursorStyle == TerminalEmulator.TERMINAL_CURSOR_STYLE_BAR) right -= ((right - left) * 3) / 4f + canvas.drawRect(left, y - cursorHeight, right, y, textPaint) + } + + if ((effect and TextStyle.CHARACTER_ATTRIBUTE_INVISIBLE) == 0) { + if (dim) { + var red = 0xFF and (foreColor shr 16) + var green = 0xFF and (foreColor shr 8) + var blue = 0xFF and foreColor + // Dim color handling used by libvte which in turn took it from xterm + // (https://bug735245.bugzilla-attachments.gnome.org/attachment.cgi?id=284267): + red = red * 2 / 3 + green = green * 2 / 3 + blue = blue * 2 / 3 + foreColor = -0x1000000 or (red shl 16) or (green shl 8) or blue + } + + textPaint.isFakeBoldText = bold + textPaint.isUnderlineText = underline + textPaint.textSkewX = if (italic) -0.35f else 0f + textPaint.isStrikeThruText = strikeThrough + textPaint.color = foreColor + + // The text alignment is the default Paint.Align.LEFT. + canvas.drawTextRun( + text, startCharIndex, runWidthChars, startCharIndex, runWidthChars, + left, y - fontLineSpacingAndAscent, false, textPaint, + ) + } + + if (savedMatrix) canvas.restore() + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/terminal/TerminalScreen.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/terminal/TerminalScreen.kt new file mode 100644 index 000000000..a49073644 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/terminal/TerminalScreen.kt @@ -0,0 +1,94 @@ +package com.topjohnwu.magisk.ui.terminal + +import android.graphics.Typeface +import androidx.compose.foundation.background +import androidx.compose.foundation.gestures.Orientation +import androidx.compose.foundation.gestures.rememberScrollableState +import androidx.compose.foundation.gestures.scrollable +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.drawBehind +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.drawscope.drawIntoCanvas +import androidx.compose.ui.graphics.nativeCanvas +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.unit.sp +import com.topjohnwu.magisk.terminal.TerminalEmulator +import kotlin.math.max + +@Composable +fun TerminalScreen( + modifier: Modifier = Modifier, + onEmulatorCreated: (TerminalEmulator) -> Unit = {}, +) { + val density = LocalDensity.current + val renderer = remember { + val textSizePx = with(density) { 12.sp.toPx().toInt() } + TerminalRenderer(textSizePx, Typeface.MONOSPACE) + } + + var emulator by remember { mutableStateOf(null) } + var updateTick by remember { mutableIntStateOf(0) } + var topRow by remember { mutableIntStateOf(0) } + var scrolledToBottom by remember { mutableStateOf(true) } + + BoxWithConstraints(modifier = modifier) { + val widthPx = constraints.maxWidth + val heightPx = constraints.maxHeight + val cols = max(4, (widthPx / renderer.fontWidth).toInt()) + val rows = max(4, (heightPx - renderer.fontLineSpacingAndAscent) / renderer.fontLineSpacing) + val lineHeight = renderer.fontLineSpacing.toFloat() + + LaunchedEffect(cols, rows) { + val emu = emulator + if (emu == null) { + val newEmu = TerminalEmulator(cols, rows, renderer.fontWidth.toInt(), renderer.fontLineSpacing, null) + newEmu.onScreenUpdate = { + if (scrolledToBottom) topRow = 0 + updateTick++ + } + emulator = newEmu + onEmulatorCreated(newEmu) + } else { + emu.resize(cols, rows, renderer.fontWidth.toInt(), renderer.fontLineSpacing) + } + } + + Spacer( + modifier = Modifier + .fillMaxSize() + .background(Color.Black) + .scrollable( + orientation = Orientation.Vertical, + state = rememberScrollableState { delta -> + val emu = emulator ?: return@rememberScrollableState 0f + val minTop = -emu.screen.activeTranscriptRows + val rowDelta = -(delta / lineHeight).toInt() + if (rowDelta != 0) { + val newTopRow = (topRow + rowDelta).coerceIn(minTop, 0) + topRow = newTopRow + scrolledToBottom = newTopRow >= 0 + } + delta + } + ) + .drawBehind { + @Suppress("UNUSED_EXPRESSION") + updateTick + val emu = emulator ?: return@drawBehind + drawIntoCanvas { canvas -> + renderer.render(emu, canvas.nativeCanvas, topRow, -1, -1, -1, -1) + } + } + ) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/theme/MagiskTheme.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/theme/MagiskTheme.kt new file mode 100644 index 000000000..08a37d8b5 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/theme/MagiskTheme.kt @@ -0,0 +1,39 @@ +package com.topjohnwu.magisk.ui.theme + +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.setValue +import com.topjohnwu.magisk.core.Config +import top.yukonga.miuix.kmp.theme.ColorSchemeMode +import top.yukonga.miuix.kmp.theme.LocalContentColor +import top.yukonga.miuix.kmp.theme.MiuixTheme +import top.yukonga.miuix.kmp.theme.ThemeController + +object ThemeState { + var colorMode by mutableIntStateOf(Config.colorMode) +} + +@Composable +fun MagiskTheme( + content: @Composable () -> Unit +) { + val isDark = isSystemInDarkTheme() + val mode = ThemeState.colorMode + val controller = when (mode) { + 1 -> ThemeController(ColorSchemeMode.Light) + 2 -> ThemeController(ColorSchemeMode.Dark) + 3 -> ThemeController(ColorSchemeMode.MonetSystem, isDark = isDark) + 4 -> ThemeController(ColorSchemeMode.MonetLight) + 5 -> ThemeController(ColorSchemeMode.MonetDark) + else -> ThemeController(ColorSchemeMode.System) + } + MiuixTheme(controller = controller) { + CompositionLocalProvider( + LocalContentColor provides MiuixTheme.colorScheme.onBackground, + content = content + ) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/theme/Theme.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/theme/Theme.kt new file mode 100644 index 000000000..4fb9f7288 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/theme/Theme.kt @@ -0,0 +1,50 @@ +package com.topjohnwu.magisk.ui.theme + +import com.topjohnwu.magisk.R +import com.topjohnwu.magisk.core.Config + +enum class Theme( + val themeName: String, + val themeRes: Int +) { + + Piplup( + themeName = "Piplup", + themeRes = R.style.ThemeFoundationMD2_Piplup + ), + PiplupAmoled( + themeName = "AMOLED", + themeRes = R.style.ThemeFoundationMD2_Amoled + ), + Rayquaza( + themeName = "Rayquaza", + themeRes = R.style.ThemeFoundationMD2_Rayquaza + ), + Zapdos( + themeName = "Zapdos", + themeRes = R.style.ThemeFoundationMD2_Zapdos + ), + Charmeleon( + themeName = "Charmeleon", + themeRes = R.style.ThemeFoundationMD2_Charmeleon + ), + Mew( + themeName = "Mew", + themeRes = R.style.ThemeFoundationMD2_Mew + ), + Salamence( + themeName = "Salamence", + themeRes = R.style.ThemeFoundationMD2_Salamence + ), + Fraxure( + themeName = "Fraxure (Legacy)", + themeRes = R.style.ThemeFoundationMD2_Fraxure + ); + + val isSelected get() = Config.themeOrdinal == ordinal + + companion object { + val selected get() = values().getOrNull(Config.themeOrdinal) ?: Piplup + } + +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/util/DrawablePainter.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/util/DrawablePainter.kt new file mode 100644 index 000000000..51b4f8618 --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/ui/util/DrawablePainter.kt @@ -0,0 +1,22 @@ +package com.topjohnwu.magisk.ui.util + +import android.graphics.Bitmap +import android.graphics.drawable.Drawable +import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember +import androidx.compose.ui.graphics.asImageBitmap +import androidx.compose.ui.graphics.painter.BitmapPainter +import androidx.compose.ui.graphics.painter.Painter + +@Composable +fun rememberDrawablePainter(drawable: Drawable): Painter { + return remember(drawable) { + val w = drawable.intrinsicWidth.coerceAtLeast(1) + val h = drawable.intrinsicHeight.coerceAtLeast(1) + val bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888) + val canvas = android.graphics.Canvas(bitmap) + drawable.setBounds(0, 0, w, h) + drawable.draw(canvas) + BitmapPainter(bitmap.asImageBitmap()) + } +} diff --git a/app/apk-ng/src/main/java/com/topjohnwu/magisk/utils/AccessibilityUtils.kt b/app/apk-ng/src/main/java/com/topjohnwu/magisk/utils/AccessibilityUtils.kt new file mode 100644 index 000000000..4ac85267f --- /dev/null +++ b/app/apk-ng/src/main/java/com/topjohnwu/magisk/utils/AccessibilityUtils.kt @@ -0,0 +1,14 @@ +package com.topjohnwu.magisk.utils + +import android.content.ContentResolver +import android.provider.Settings + +class AccessibilityUtils { + companion object { + fun isAnimationEnabled(cr: ContentResolver): Boolean { + return !(Settings.Global.getFloat(cr, Settings.Global.ANIMATOR_DURATION_SCALE, 1.0f) == 0.0f + && Settings.Global.getFloat(cr, Settings.Global.TRANSITION_ANIMATION_SCALE, 1.0f) == 0.0f + && Settings.Global.getFloat(cr, Settings.Global.WINDOW_ANIMATION_SCALE, 1.0f) == 0.0f) + } + } +} diff --git a/app/apk-ng/src/main/res/color/color_card_background_color_selector.xml b/app/apk-ng/src/main/res/color/color_card_background_color_selector.xml new file mode 100644 index 000000000..10805d34e --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_card_background_color_selector.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/app/apk-ng/src/main/res/color/color_error_transient.xml b/app/apk-ng/src/main/res/color/color_error_transient.xml new file mode 100644 index 000000000..22fd9491c --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_error_transient.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/color/color_menu_tint.xml b/app/apk-ng/src/main/res/color/color_menu_tint.xml new file mode 100644 index 000000000..030b0e573 --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_menu_tint.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/color/color_on_primary_transient.xml b/app/apk-ng/src/main/res/color/color_on_primary_transient.xml new file mode 100644 index 000000000..d82ebd18d --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_on_primary_transient.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/color/color_primary_error_transient.xml b/app/apk-ng/src/main/res/color/color_primary_error_transient.xml new file mode 100644 index 000000000..b0bcb827a --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_primary_error_transient.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/color/color_primary_transient.xml b/app/apk-ng/src/main/res/color/color_primary_transient.xml new file mode 100644 index 000000000..b792af898 --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_primary_transient.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/color/color_state_primary_transient.xml b/app/apk-ng/src/main/res/color/color_state_primary_transient.xml new file mode 100644 index 000000000..f979fd372 --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_state_primary_transient.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/color/color_text_transient.xml b/app/apk-ng/src/main/res/color/color_text_transient.xml new file mode 100644 index 000000000..b394648cb --- /dev/null +++ b/app/apk-ng/src/main/res/color/color_text_transient.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/avd_bug_from_filled.xml b/app/apk-ng/src/main/res/drawable/avd_bug_from_filled.xml new file mode 100644 index 000000000..b56ed84de --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_bug_from_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_bug_to_filled.xml b/app/apk-ng/src/main/res/drawable/avd_bug_to_filled.xml new file mode 100644 index 000000000..a0022e32c --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_bug_to_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_circle_check_from_filled.xml b/app/apk-ng/src/main/res/drawable/avd_circle_check_from_filled.xml new file mode 100644 index 000000000..c39d8e0b6 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_circle_check_from_filled.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_circle_check_to_filled.xml b/app/apk-ng/src/main/res/drawable/avd_circle_check_to_filled.xml new file mode 100644 index 000000000..b021ca24b --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_circle_check_to_filled.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_home_from_filled.xml b/app/apk-ng/src/main/res/drawable/avd_home_from_filled.xml new file mode 100644 index 000000000..d43306504 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_home_from_filled.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_home_to_filled.xml b/app/apk-ng/src/main/res/drawable/avd_home_to_filled.xml new file mode 100644 index 000000000..3f9ff4cf9 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_home_to_filled.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_module_from_filled.xml b/app/apk-ng/src/main/res/drawable/avd_module_from_filled.xml new file mode 100644 index 000000000..3d464b059 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_module_from_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_module_to_filled.xml b/app/apk-ng/src/main/res/drawable/avd_module_to_filled.xml new file mode 100644 index 000000000..bab708f16 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_module_to_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_settings_from_filled.xml b/app/apk-ng/src/main/res/drawable/avd_settings_from_filled.xml new file mode 100644 index 000000000..0b5bea43c --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_settings_from_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_settings_to_filled.xml b/app/apk-ng/src/main/res/drawable/avd_settings_to_filled.xml new file mode 100644 index 000000000..a5fb8da73 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_settings_to_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_superuser_from_filled.xml b/app/apk-ng/src/main/res/drawable/avd_superuser_from_filled.xml new file mode 100644 index 000000000..e5e63721b --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_superuser_from_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/avd_superuser_to_filled.xml b/app/apk-ng/src/main/res/drawable/avd_superuser_to_filled.xml new file mode 100644 index 000000000..287e9a9d0 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/avd_superuser_to_filled.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_bug_filled_md2.xml b/app/apk-ng/src/main/res/drawable/ic_bug_filled_md2.xml new file mode 100644 index 000000000..6849c1b2a --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_bug_filled_md2.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_bug_md2.xml b/app/apk-ng/src/main/res/drawable/ic_bug_md2.xml new file mode 100644 index 000000000..e9ea123fc --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_bug_md2.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_bug_outlined_md2.xml b/app/apk-ng/src/main/res/drawable/ic_bug_outlined_md2.xml new file mode 100644 index 000000000..2c9a0a795 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_bug_outlined_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_check_circle_checked_md2.xml b/app/apk-ng/src/main/res/drawable/ic_check_circle_checked_md2.xml new file mode 100644 index 000000000..926f8e6ae --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_check_circle_checked_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_check_circle_md2.xml b/app/apk-ng/src/main/res/drawable/ic_check_circle_md2.xml new file mode 100644 index 000000000..09f36eefc --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_check_circle_md2.xml @@ -0,0 +1,25 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_check_circle_unchecked_md2.xml b/app/apk-ng/src/main/res/drawable/ic_check_circle_unchecked_md2.xml new file mode 100644 index 000000000..1fae2758e --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_check_circle_unchecked_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_check_md2.xml b/app/apk-ng/src/main/res/drawable/ic_check_md2.xml new file mode 100644 index 000000000..ff6645704 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_check_md2.xml @@ -0,0 +1,12 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_delete_md2.xml b/app/apk-ng/src/main/res/drawable/ic_delete_md2.xml new file mode 100644 index 000000000..e451bfa33 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_delete_md2.xml @@ -0,0 +1,12 @@ + + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_download_md2.xml b/app/apk-ng/src/main/res/drawable/ic_download_md2.xml new file mode 100644 index 000000000..5d3c38484 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_download_md2.xml @@ -0,0 +1,12 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_home_filled_md2.xml b/app/apk-ng/src/main/res/drawable/ic_home_filled_md2.xml new file mode 100644 index 000000000..0dafe8a4a --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_home_filled_md2.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_home_md2.xml b/app/apk-ng/src/main/res/drawable/ic_home_md2.xml new file mode 100644 index 000000000..a5d90b4d9 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_home_md2.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_home_outlined_md2.xml b/app/apk-ng/src/main/res/drawable/ic_home_outlined_md2.xml new file mode 100644 index 000000000..38bad7cc5 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_home_outlined_md2.xml @@ -0,0 +1,11 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_install.xml b/app/apk-ng/src/main/res/drawable/ic_install.xml new file mode 100644 index 000000000..9e71aa185 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_install.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_manager.xml b/app/apk-ng/src/main/res/drawable/ic_manager.xml new file mode 100644 index 000000000..001df45e3 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_manager.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_module_filled_md2.xml b/app/apk-ng/src/main/res/drawable/ic_module_filled_md2.xml new file mode 100644 index 000000000..8d4c14e57 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_module_filled_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_module_md2.xml b/app/apk-ng/src/main/res/drawable/ic_module_md2.xml new file mode 100644 index 000000000..d93278f5b --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_module_md2.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_module_outlined_md2.xml b/app/apk-ng/src/main/res/drawable/ic_module_outlined_md2.xml new file mode 100644 index 000000000..fd83b65c4 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_module_outlined_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_module_storage_md2.xml b/app/apk-ng/src/main/res/drawable/ic_module_storage_md2.xml new file mode 100644 index 000000000..9505cddde --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_module_storage_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_notifications_md2.xml b/app/apk-ng/src/main/res/drawable/ic_notifications_md2.xml new file mode 100644 index 000000000..c55141254 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_notifications_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_restart.xml b/app/apk-ng/src/main/res/drawable/ic_restart.xml new file mode 100644 index 000000000..b4f8eaee9 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_restart.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_save_md2.xml b/app/apk-ng/src/main/res/drawable/ic_save_md2.xml new file mode 100644 index 000000000..81d0e3b04 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_save_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_search_md2.xml b/app/apk-ng/src/main/res/drawable/ic_search_md2.xml new file mode 100644 index 000000000..d290daebb --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_search_md2.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_settings_filled_md2.xml b/app/apk-ng/src/main/res/drawable/ic_settings_filled_md2.xml new file mode 100644 index 000000000..6044b0f0f --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_settings_filled_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_settings_md2.xml b/app/apk-ng/src/main/res/drawable/ic_settings_md2.xml new file mode 100644 index 000000000..9d294bff8 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_settings_md2.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_settings_outlined_md2.xml b/app/apk-ng/src/main/res/drawable/ic_settings_outlined_md2.xml new file mode 100644 index 000000000..6c20efa2f --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_settings_outlined_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_superuser_filled_md2.xml b/app/apk-ng/src/main/res/drawable/ic_superuser_filled_md2.xml new file mode 100644 index 000000000..dde6afed0 --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_superuser_filled_md2.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/apk-ng/src/main/res/drawable/ic_superuser_md2.xml b/app/apk-ng/src/main/res/drawable/ic_superuser_md2.xml new file mode 100644 index 000000000..374959c7c --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_superuser_md2.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_superuser_outlined_md2.xml b/app/apk-ng/src/main/res/drawable/ic_superuser_outlined_md2.xml new file mode 100644 index 000000000..3c279ccbe --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_superuser_outlined_md2.xml @@ -0,0 +1,9 @@ + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/drawable/ic_update_md2.xml b/app/apk-ng/src/main/res/drawable/ic_update_md2.xml new file mode 100644 index 000000000..7595bcf4d --- /dev/null +++ b/app/apk-ng/src/main/res/drawable/ic_update_md2.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/values-night/styles_md2.xml b/app/apk-ng/src/main/res/values-night/styles_md2.xml new file mode 100644 index 000000000..691508104 --- /dev/null +++ b/app/apk-ng/src/main/res/values-night/styles_md2.xml @@ -0,0 +1,6 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/apk-ng/src/main/res/values-v27/themes.xml b/app/apk-ng/src/main/res/values-v27/themes.xml new file mode 100644 index 000000000..a92226323 --- /dev/null +++ b/app/apk-ng/src/main/res/values-v27/themes.xml @@ -0,0 +1,18 @@ + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/values/styles_md2_appearance.xml b/app/apk-ng/src/main/res/values/styles_md2_appearance.xml new file mode 100644 index 000000000..fde3a5a0a --- /dev/null +++ b/app/apk-ng/src/main/res/values/styles_md2_appearance.xml @@ -0,0 +1,69 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/values/styles_md2_impl.xml b/app/apk-ng/src/main/res/values/styles_md2_impl.xml new file mode 100644 index 000000000..e615d0e91 --- /dev/null +++ b/app/apk-ng/src/main/res/values/styles_md2_impl.xml @@ -0,0 +1,109 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/values/themes.xml b/app/apk-ng/src/main/res/values/themes.xml new file mode 100644 index 000000000..09078e38e --- /dev/null +++ b/app/apk-ng/src/main/res/values/themes.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/apk-ng/src/main/res/values/themes_override.xml b/app/apk-ng/src/main/res/values/themes_override.xml new file mode 100644 index 000000000..90de13757 --- /dev/null +++ b/app/apk-ng/src/main/res/values/themes_override.xml @@ -0,0 +1,17 @@ + + + + + + + + + diff --git a/app/buildSrc/build.gradle.kts b/app/buildSrc/build.gradle.kts index ee770f35e..5fdb74d31 100644 --- a/app/buildSrc/build.gradle.kts +++ b/app/buildSrc/build.gradle.kts @@ -18,6 +18,8 @@ gradlePlugin { dependencies { implementation(kotlin("gradle-plugin", libs.versions.kotlin.get())) + implementation("org.jetbrains.kotlin:compose-compiler-gradle-plugin:${libs.versions.kotlin.get()}") + implementation("org.jetbrains.kotlin:kotlin-serialization:${libs.versions.kotlin.get()}") implementation(libs.android.gradle.plugin) implementation(libs.jgit) } diff --git a/app/core/src/main/java/com/topjohnwu/magisk/core/Config.kt b/app/core/src/main/java/com/topjohnwu/magisk/core/Config.kt index 7fd4f8598..e2dd5a928 100644 --- a/app/core/src/main/java/com/topjohnwu/magisk/core/Config.kt +++ b/app/core/src/main/java/com/topjohnwu/magisk/core/Config.kt @@ -38,6 +38,7 @@ object Config : PreferenceConfig, DBConfig { const val CUSTOM_CHANNEL = "custom_channel" const val LOCALE = "locale" const val DARK_THEME = "dark_theme_extended" + const val COLOR_MODE = "color_mode" const val DOWNLOAD_DIR = "download_dir" const val SAFETY = "safety_notice" const val THEME_ORDINAL = "theme_ordinal" @@ -86,6 +87,7 @@ object Config : PreferenceConfig, DBConfig { // su notification const val NO_NOTIFICATION = 0 const val NOTIFICATION_TOAST = 1 + const val NOTIFICATION_STATUS_BAR = 2 // su auto response const val SU_PROMPT = 0 @@ -107,6 +109,7 @@ object Config : PreferenceConfig, DBConfig { var safetyNotice by preference(Key.SAFETY, true) var darkTheme by preference(Key.DARK_THEME, -1) var themeOrdinal by preference(Key.THEME_ORDINAL, 0) + var colorMode by preference(Key.COLOR_MODE, 0) private var checkUpdatePrefs by preference(Key.CHECK_UPDATES, true) private var localePrefs by preference(Key.LOCALE, "") diff --git a/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuCallbackHandler.kt b/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuCallbackHandler.kt index 7c0d53172..ebf7a887c 100644 --- a/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuCallbackHandler.kt +++ b/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuCallbackHandler.kt @@ -3,6 +3,7 @@ package com.topjohnwu.magisk.core.su import android.content.Context import android.os.Bundle import android.widget.Toast +import com.topjohnwu.magisk.core.AppContext import com.topjohnwu.magisk.core.BuildConfig import com.topjohnwu.magisk.core.Config import com.topjohnwu.magisk.core.R @@ -12,6 +13,7 @@ import com.topjohnwu.magisk.core.ktx.getPackageInfo import com.topjohnwu.magisk.core.ktx.toast import com.topjohnwu.magisk.core.model.su.SuPolicy import com.topjohnwu.magisk.core.model.su.createSuLog +import com.topjohnwu.magisk.view.Notifications import kotlinx.coroutines.runBlocking import timber.log.Timber @@ -69,10 +71,12 @@ object SuCallbackHandler { } }.getOrNull() ?: createSuLog(fromUid, toUid, pid, command, policy, target, seContext, gids) - if (notify) - notify(context, log.action >= SuPolicy.ALLOW, log.appName) - runBlocking { ServiceLocator.logRepo.insert(log) } + + if (notify || Config.suNotification == Config.Value.NOTIFICATION_STATUS_BAR) + notify(context, log.action >= SuPolicy.ALLOW, log.appName) + SuEvents.notifyLogUpdated() + SuEvents.notifyPolicyChanged() } private fun handleNotify(context: Context, data: Bundle) { @@ -87,16 +91,30 @@ object SuCallbackHandler { }.getOrNull() ?: "[UID] $uid" notify(context, policy >= SuPolicy.ALLOW, appName) + SuEvents.notifyPolicyChanged() + } + + fun notify(granted: Boolean, appName: String) { + when (Config.suNotification) { + Config.Value.NOTIFICATION_TOAST -> { + val resId = if (granted) R.string.su_allow_toast else R.string.su_deny_toast + AppContext.toast(AppContext.getString(resId, appName), Toast.LENGTH_SHORT) + } + Config.Value.NOTIFICATION_STATUS_BAR -> { + Notifications.suNotification(granted, appName) + } + } } private fun notify(context: Context, granted: Boolean, appName: String) { - if (Config.suNotification == Config.Value.NOTIFICATION_TOAST) { - val resId = if (granted) - R.string.su_allow_toast - else - R.string.su_deny_toast - - context.toast(context.getString(resId, appName), Toast.LENGTH_SHORT) + when (Config.suNotification) { + Config.Value.NOTIFICATION_TOAST -> { + val resId = if (granted) R.string.su_allow_toast else R.string.su_deny_toast + context.toast(context.getString(resId, appName), Toast.LENGTH_SHORT) + } + Config.Value.NOTIFICATION_STATUS_BAR -> { + Notifications.suNotification(granted, appName) + } } } } diff --git a/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuEvents.kt b/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuEvents.kt new file mode 100644 index 000000000..e0ffe51a4 --- /dev/null +++ b/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuEvents.kt @@ -0,0 +1,20 @@ +package com.topjohnwu.magisk.core.su + +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.asSharedFlow + +object SuEvents { + private val _policyChanged = MutableSharedFlow(extraBufferCapacity = 64) + val policyChanged = _policyChanged.asSharedFlow() + + private val _logUpdated = MutableSharedFlow(extraBufferCapacity = 64) + val logUpdated = _logUpdated.asSharedFlow() + + fun notifyPolicyChanged() { + _policyChanged.tryEmit(Unit) + } + + fun notifyLogUpdated() { + _logUpdated.tryEmit(Unit) + } +} diff --git a/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuRequestHandler.kt b/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuRequestHandler.kt index a624c01ce..37cebabd9 100644 --- a/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuRequestHandler.kt +++ b/app/core/src/main/java/com/topjohnwu/magisk/core/su/SuRequestHandler.kt @@ -6,8 +6,12 @@ import android.content.pm.PackageManager import com.topjohnwu.magisk.core.BuildConfig import com.topjohnwu.magisk.core.Config import com.topjohnwu.magisk.core.data.magiskdb.PolicyDao +import com.topjohnwu.magisk.core.di.ServiceLocator +import com.topjohnwu.magisk.core.ktx.getLabel import com.topjohnwu.magisk.core.ktx.getPackageInfo +import com.topjohnwu.magisk.core.model.su.SuLog import com.topjohnwu.magisk.core.model.su.SuPolicy +import com.topjohnwu.magisk.view.Notifications import com.topjohnwu.superuser.Shell import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext @@ -25,6 +29,7 @@ class SuRequestHandler( private lateinit var output: File private lateinit var policy: SuPolicy + private var pid: Int = -1 lateinit var pkgInfo: PackageInfo private set @@ -55,7 +60,7 @@ class SuRequestHandler( private suspend fun init(intent: Intent): Boolean { val uid = intent.getIntExtra("uid", -1) - val pid = intent.getIntExtra("pid", -1) + pid = intent.getIntExtra("pid", -1) val fifo = intent.getStringExtra("fifo") if (uid <= 0 || pid <= 0 || fifo == null) { Timber.e("Unexpected extras: uid=[${uid}], pid=[${pid}], fifo=[${fifo}]") @@ -104,6 +109,32 @@ class SuRequestHandler( } if (time >= 0) { policyDB.update(policy) + + val appInfo = pkgInfo.applicationInfo + val appName = appInfo?.getLabel(pm) + ?: pkgInfo.sharedUserId ?: "[UID] ${policy.uid}" + val packageName = appInfo?.let { pm.getNameForUid(it.uid) } + ?: pkgInfo.sharedUserId ?: "[UID] ${policy.uid}" + + val log = SuLog( + fromUid = policy.uid, + toUid = 0, + fromPid = pid, + packageName = packageName, + appName = appName, + command = "", + action = policy.policy, + target = -1, + context = "", + gids = "", + ) + ServiceLocator.logRepo.insert(log) + + val granted = policy.policy >= SuPolicy.ALLOW + SuCallbackHandler.notify(granted, appName) + + SuEvents.notifyPolicyChanged() + SuEvents.notifyLogUpdated() } } } diff --git a/app/core/src/main/java/com/topjohnwu/magisk/core/view/Notifications.kt b/app/core/src/main/java/com/topjohnwu/magisk/core/view/Notifications.kt index c70fd3fe5..4a28beea0 100644 --- a/app/core/src/main/java/com/topjohnwu/magisk/core/view/Notifications.kt +++ b/app/core/src/main/java/com/topjohnwu/magisk/core/view/Notifications.kt @@ -28,6 +28,7 @@ object Notifications { private const val UPDATE_CHANNEL = "update" private const val PROGRESS_CHANNEL = "progress" private const val UPDATED_CHANNEL = "updated" + private const val SU_CHANNEL = "su_notification" private val nextId = AtomicInteger(APP_UPDATE_AVAILABLE_ID) @@ -40,7 +41,9 @@ object Notifications { getString(R.string.progress_channel), NotificationManager.IMPORTANCE_LOW) val channel3 = NotificationChannel(UPDATED_CHANNEL, getString(R.string.updated_channel), NotificationManager.IMPORTANCE_HIGH) - mgr.createNotificationChannels(listOf(channel, channel2, channel3)) + val channel4 = NotificationChannel(SU_CHANNEL, + getString(R.string.su_notification_channel), NotificationManager.IMPORTANCE_HIGH) + mgr.createNotificationChannels(listOf(channel, channel2, channel3, channel4)) } } } @@ -101,5 +104,37 @@ object Notifications { return builder } + private const val SU_NOTIFICATION_TIMEOUT_MS = 3_000L + + @SuppressLint("InlinedApi") + fun suNotification(granted: Boolean, appName: String) { + AppContext.apply { + val flag = PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT + val pending = PendingIntent.getActivity(this, 0, selfLaunchIntent(), flag) + val title = getString( + if (granted) R.string.su_notification_granted_title + else R.string.su_notification_denied_title + ) + val text = getString( + if (granted) R.string.su_allow_toast + else R.string.su_deny_toast, + appName + ) + val builder = if (SDK_INT >= Build.VERSION_CODES.O) { + Notification.Builder(this, SU_CHANNEL) + .setSmallIcon(getBitmap(R.drawable.ic_magisk_outline).toIcon()) + } else { + Notification.Builder(this).setPriority(Notification.PRIORITY_HIGH) + .setSmallIcon(R.drawable.ic_magisk_outline) + } + .setContentIntent(pending) + .setContentTitle(title) + .setContentText(text) + .setAutoCancel(true) + .setTimeoutAfter(SU_NOTIFICATION_TIMEOUT_MS) + mgr.notify(nextId(), builder.build()) + } + } + fun nextId() = nextId.incrementAndGet() } diff --git a/app/core/src/main/res/values/arrays.xml b/app/core/src/main/res/values/arrays.xml index e64e4970c..3235634c2 100644 --- a/app/core/src/main/res/values/arrays.xml +++ b/app/core/src/main/res/values/arrays.xml @@ -34,6 +34,7 @@ @string/none @string/toast + @string/notification @@ -66,4 +67,13 @@ @string/settings_update_debug @string/settings_update_custom + + + @string/color_mode_system + @string/color_mode_light + @string/color_mode_dark + @string/color_mode_monet_system + @string/color_mode_monet_light + @string/color_mode_monet_dark + diff --git a/app/core/src/main/res/values/resources.xml b/app/core/src/main/res/values/resources.xml index 1c1f526e4..b522b5b3d 100644 --- a/app/core/src/main/res/values/resources.xml +++ b/app/core/src/main/res/values/resources.xml @@ -4,6 +4,7 @@ Magisk Zygisk + Ramdisk PayPal diff --git a/app/core/src/main/res/values/strings.xml b/app/core/src/main/res/values/strings.xml index 19c56810c..ec2e87862 100644 --- a/app/core/src/main/res/values/strings.xml +++ b/app/core/src/main/res/values/strings.xml @@ -17,16 +17,24 @@ Update N/A Hide + Restore Package App + Core + Reinstall Download Magisk ONLY from the official GitHub page. Files from unknown sources can be malicious! Support Us Follow Us Source Magisk is, and always will be, free, and open source. However, you can show us that you care by making a donation. + Donate + Documents + Report Bugs + Status Installed Latest Invalid update channel + Uninstall Uninstall Magisk All modules will be disabled/removed!\nRoot will be removed!\nAny internal storage unencrypted through the use of Magisk will be re-encrypted! @@ -40,7 +48,10 @@ Let\'s go Press to download and install Direct install (Recommended) + Directly install Magisk to the boot partition Install to inactive slot (After OTA) + Install to the inactive slot after an OTA update + Patch a raw image, ODIN tar, or payload.bin file Your device will be FORCED to boot to the current inactive slot after a reboot!\nOnly use this option after OTA is done.\nContinue? Additional setup Select and patch a file @@ -49,7 +60,7 @@ Installation - Superuser request + This app is requesting root permission. Grants full access to your device. Deny if you\'re not sure! Because an app is obscuring a Superuser request, Magisk can\'t verify your response. Deny Prompt @@ -73,7 +84,11 @@ Revoke? Confirm to revoke %1$s Superuser rights Toast + Notification None + Superuser Notifications + Superuser Granted + Superuser Denied Notifications Revoke No apps have asked for Superuser permission yet. @@ -84,6 +99,12 @@ Save log Clear log now Log successfully cleared + Save log + Clear log + Back + Superuser Setting + Enabled + Disabled PID: %1$d Target UID: %1$d Target PID: %s @@ -94,6 +115,12 @@ Show system apps Show OS apps Filter by name + Sort by name + Sort by package name + Sort by install time + Sort by update time + Reverse order + Sort Search @@ -174,6 +201,13 @@ Restrict root capabilities Will restrict new Superuser apps by default. Warning: this will break most apps. Don\'t enable it unless you know what you\'re doing. Customization + Color mode + System + Light + Dark + Monet (System) + Monet (Light) + Monet (Dark) Add a pretty shortcut to the home screen in case the name and icon are difficult to recognize after hiding the app DNS over HTTPS Workaround DNS poisoning in some nations diff --git a/app/gradle/libs.versions.toml b/app/gradle/libs.versions.toml index 5f8c4a23e..c030c3e4d 100644 --- a/app/gradle/libs.versions.toml +++ b/app/gradle/libs.versions.toml @@ -1,5 +1,5 @@ [versions] -kotlin = "2.3.0" +kotlin = "2.3.10" android = "9.0.1" ksp = "2.3.4" rikka = "1.3.0" @@ -8,6 +8,12 @@ libsu = "6.0.0" okhttp = "5.3.2" retrofit = "3.0.0" room = "2.8.4" +compose-bom = "2026.02.01" +lifecycle = "2.10.0" +activity-compose = "1.12.4" +miuix = "0.8.6" +navigation3 = "1.1.0-alpha05" +navigationevent = "1.0.2" [libraries] bcpkix = { module = "org.bouncycastle:bcpkix-jdk18on", version = "1.83" } @@ -57,6 +63,21 @@ rikka-recyclerview = { module = "dev.rikka.rikkax.recyclerview:recyclerview-ktx" rikka-layoutinflater = { module = "dev.rikka.rikkax.layoutinflater:layoutinflater", version.ref = "rikka" } rikka-insets = { module = "dev.rikka.rikkax.insets:insets", version.ref = "rikka" } +# Compose +activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activity-compose" } +compose-bom = { module = "androidx.compose:compose-bom", version.ref = "compose-bom" } +compose-ui = { module = "androidx.compose.ui:ui" } +compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling" } +compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" } +lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "lifecycle" } +lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "lifecycle" } +miuix = { module = "top.yukonga.miuix.kmp:miuix-android", version.ref = "miuix" } +miuix-icons = { module = "top.yukonga.miuix.kmp:miuix-icons-android", version.ref = "miuix" } +miuix-navigation3-ui = { module = "top.yukonga.miuix.kmp:miuix-navigation3-ui-android", version.ref = "miuix" } +navigation3-runtime = { module = "androidx.navigation3:navigation3-runtime", version.ref = "navigation3" } +navigationevent-compose = { module = "androidx.navigationevent:navigationevent-compose", version.ref = "navigationevent" } +lifecycle-viewmodel-navigation3 = { module = "androidx.lifecycle:lifecycle-viewmodel-navigation3", version.ref = "lifecycle" } + # Build plugins android-gradle-plugin = { module = "com.android.tools.build:gradle", version.ref = "android" } @@ -65,4 +86,4 @@ ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" } lsparanoid = { id = "org.lsposed.lsparanoid", version = "0.6.0" } moshix = { id = "dev.zacsweers.moshix", version = "0.34.4" } legacy-kapt = { id = "com.android.legacy-kapt", version.ref = "android" } -navigation-safeargs = { id = "androidx.navigation.safeargs.kotlin", version.ref = "navigation" } +navigation-safeargs = { id = "androidx.navigation.safeargs.kotlin", version.ref = "navigation" } \ No newline at end of file diff --git a/app/settings.gradle.kts b/app/settings.gradle.kts index 836ef936d..b9a545447 100644 --- a/app/settings.gradle.kts +++ b/app/settings.gradle.kts @@ -16,4 +16,4 @@ pluginManagement { } rootProject.name = "Magisk" -include(":apk", ":core", ":shared", ":stub", ":test") +include(":apk-ng", ":core", ":shared", ":stub", ":test") diff --git a/build.py b/build.py index 59eee6e2a..40f9de0e3 100755 --- a/build.py +++ b/build.py @@ -448,6 +448,12 @@ def build_app(): cp(source, target) +def build_app_ng(): + header("* Building the next generation Magisk app") + apk = build_apk(":apk-ng") + header(f"Output: {apk}") + + def build_stub(): header("* Building the stub app") apk = build_apk(":stub") @@ -833,6 +839,10 @@ def parse_args(): app_parser = subparsers.add_parser("app", help="build the Magisk app") + app_ng_parser = subparsers.add_parser( + "app-ng", help="build the next generation Magisk app" + ) + stub_parser = subparsers.add_parser("stub", help="build the stub app") test_parser = subparsers.add_parser("test", help="build the test app") @@ -892,6 +902,7 @@ def parse_args(): rustup_parser.set_defaults(func=setup_rustup) gen_parser.set_defaults(func=gen_ide) app_parser.set_defaults(func=build_app) + app_ng_parser.set_defaults(func=build_app_ng) stub_parser.set_defaults(func=build_stub) test_parser.set_defaults(func=build_test) emu_parser.set_defaults(func=setup_avd)