mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-20 05:16:01 +00:00
Merge remote-tracking branch 'droiddeck/main' into feat/malibridge
# Conflicts: # README.md # app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java # app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt # app/src/main/res/values-ar/strings.xml # app/src/main/res/values-b+es+419/strings.xml # app/src/main/res/values-bg/strings.xml # app/src/main/res/values-cs/strings.xml # app/src/main/res/values-da/strings.xml # app/src/main/res/values-de/strings.xml # app/src/main/res/values-el/strings.xml # app/src/main/res/values-es/strings.xml # app/src/main/res/values-fi/strings.xml # app/src/main/res/values-fr/strings.xml # app/src/main/res/values-hi/strings.xml # app/src/main/res/values-hu/strings.xml # app/src/main/res/values-in/strings.xml # app/src/main/res/values-it/strings.xml # app/src/main/res/values-ja/strings.xml # app/src/main/res/values-ko/strings.xml # app/src/main/res/values-ms/strings.xml # app/src/main/res/values-nb/strings.xml # app/src/main/res/values-nl/strings.xml # app/src/main/res/values-pl/strings.xml # app/src/main/res/values-pt-rPT/strings.xml # app/src/main/res/values-pt/strings.xml # app/src/main/res/values-ro/strings.xml # app/src/main/res/values-ru/strings.xml # app/src/main/res/values-sv/strings.xml # app/src/main/res/values-th/strings.xml # app/src/main/res/values-tr/strings.xml # app/src/main/res/values-uk/strings.xml # app/src/main/res/values-vi/strings.xml # app/src/main/res/values-zh-rCN/strings.xml # app/src/main/res/values-zh-rHK/strings.xml # app/src/main/res/values-zh-rTW/strings.xml # app/src/main/res/values/strings.xml # tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env
This commit is contained in:
commit
0a5955d6fa
731 files changed
+54131
-2491
No files matched your search
@@ -360,6 +360,8 @@ object BattleNet {
|
||||
if (ComponentsManager.gameComponents(context, scope)["fex"] != file) {
|
||||
ComponentsManager.setGameComponent(context, scope, "fex", file)
|
||||
Log.i(TAG, "FEX for the Battle.net prefix: $file")
|
||||
} else if (ComponentsManager.republish(context)) {
|
||||
Log.i(TAG, "FEX for the Battle.net prefix: $file, now in every installed Proton")
|
||||
}
|
||||
return file
|
||||
}
|
||||
|
||||
@@ -180,7 +180,8 @@ object BwrapSpawner {
|
||||
val env = LinkedHashMap<String, String>()
|
||||
request.optJSONObject("env")?.let { e -> e.keys().forEach { k -> env[k] = e.getString(k) } }
|
||||
if (binds.any { it.guest == "/dev" }) gpu(rootfs, root, env)?.forEach { addBind(it) }
|
||||
preload(session, rootfs, env).forEach { addBind(it) }
|
||||
val libc = listOf("/usr/lib/aarch64-linux-gnu/libc.so.6", "/lib/aarch64-linux-gnu/libc.so.6").map { hostPath(binds, root.path, it) }
|
||||
if (preloadFits(rootfs, libc.firstOrNull { File(it).isFile } ?: libc.first())) preload(session, rootfs, env).forEach { addBind(it) }
|
||||
zypakShims(binds, root, dir).forEach { addBind(it) }
|
||||
browserSandboxes(env)
|
||||
return Plan(root, binds, request.optString("cwd", "/").ifEmpty { "/" }, argv, env)
|
||||
@@ -188,17 +189,21 @@ object BwrapSpawner {
|
||||
|
||||
private const val GPU_DIR = "/run/droiddeck-gpu"
|
||||
|
||||
private val LIB_DIRS = listOf("usr/lib/aarch64-linux-gnu", "usr/lib")
|
||||
private val GPU_LIBS = listOf("libdisplay-info.so.3", "libdisplay-info.so.2", "libSPIRV-Tools.so", "libSPIRV-Tools-opt.so")
|
||||
|
||||
private fun runtimeLib(rootfs: String, name: String): File? =
|
||||
LIB_DIRS.map { File(rootfs, "$it/$name") }.firstOrNull { it.exists() }
|
||||
|
||||
private fun gpu(rootfs: String, root: File, env: MutableMap<String, String>): List<Bind>? {
|
||||
env["VKBRIDGE_SOCKET"]?.let { sock -> if (File(sock).exists()) return bridgeGpu(rootfs, root, env, sock) }
|
||||
val lib = File(rootfs, "usr/lib")
|
||||
val driver = File(lib, "libvulkan_freedreno.so")
|
||||
if (!driver.isFile || !File("/dev/kgsl-3d0").exists()) return null
|
||||
val driver = runtimeLib(rootfs, "libvulkan_freedreno.so")
|
||||
if (driver == null || !File("/dev/kgsl-3d0").exists()) return null
|
||||
if (env.containsKey("VK_ICD_FILENAMES") || env.containsKey("VK_DRIVER_FILES")) return null
|
||||
if (env["BL_DESKTOP"] == "1" && env["GAMESCOPE_WAYLAND_DISPLAY"] == null) return null
|
||||
val binds = ArrayList<Bind>()
|
||||
for (name in listOf("libvulkan_freedreno.so", "libdisplay-info.so.3", "libSPIRV-Tools.so", "libSPIRV-Tools-opt.so")) {
|
||||
val f = File(lib, name)
|
||||
if (!f.exists()) { Log.w(TAG, "gpu: the runtime has no $name; apps draw on the CPU"); return null }
|
||||
val binds = arrayListOf(Bind(driver.canonicalPath, "$GPU_DIR/libvulkan_freedreno.so"))
|
||||
for (name in GPU_LIBS) {
|
||||
val f = runtimeLib(rootfs, name) ?: continue
|
||||
binds.add(Bind(f.canonicalPath, "$GPU_DIR/$name"))
|
||||
}
|
||||
val icd = File(root.parentFile, "freedreno_icd.json")
|
||||
@@ -250,6 +255,27 @@ object BwrapSpawner {
|
||||
return binds
|
||||
}
|
||||
|
||||
private val GLIBC_RELEASE = Regex("release version 2\\.(\\d+)")
|
||||
private val GLIBC_NEED = Regex("GLIBC_2\\.(\\d+)")
|
||||
private val glibcMinors = java.util.concurrent.ConcurrentHashMap<String, Int>()
|
||||
|
||||
private fun glibcMinor(file: File, pattern: Regex, pick: (Sequence<Int>) -> Int?): Int? {
|
||||
val key = "${file.path}:${file.length()}:${file.lastModified()}:${pattern.pattern}"
|
||||
glibcMinors[key]?.let { return it }
|
||||
val text = runCatching { String(file.readBytes(), Charsets.ISO_8859_1) }.getOrNull() ?: return null
|
||||
return pick(pattern.findAll(text).map { it.groupValues[1].toInt() })?.also { glibcMinors[key] = it }
|
||||
}
|
||||
|
||||
internal fun preloadFits(rootfs: String, sandboxLibc: String): Boolean {
|
||||
val libc = File(sandboxLibc)
|
||||
if (!libc.isFile) return true
|
||||
val have = glibcMinor(libc, GLIBC_RELEASE) { it.firstOrNull() } ?: return true
|
||||
val libs = FileUtils.readString(File(rootfs, "etc/ld.so.preload"))?.lines()
|
||||
?.map { it.trim() }?.filter { it.startsWith("/") } ?: return true
|
||||
val need = libs.mapNotNull { File(rootfs + it).takeIf { f -> f.isFile }?.let { f -> glibcMinor(f, GLIBC_NEED) { m -> m.maxOrNull() } } }.maxOrNull() ?: return true
|
||||
return have >= need
|
||||
}
|
||||
|
||||
private const val PRELOAD_DIR = "/run/droiddeck-preload"
|
||||
private const val NET_LINK = "etc/droiddeck-net"
|
||||
|
||||
@@ -344,7 +370,15 @@ object BwrapSpawner {
|
||||
catch (e: IOException) { }
|
||||
if (process.isAlive) {
|
||||
Log.i(TAG, "sandbox $id: its bwrap is gone; stopping it")
|
||||
process.destroy()
|
||||
if (pid > 0) {
|
||||
runCatching { android.system.Os.kill(pid, android.system.OsConstants.SIGQUIT) }
|
||||
} else {
|
||||
process.destroy()
|
||||
}
|
||||
try {
|
||||
if (!process.waitFor(3, java.util.concurrent.TimeUnit.SECONDS)) process.destroyForcibly()
|
||||
} catch (_: InterruptedException) {
|
||||
}
|
||||
}
|
||||
}, "bwrap-$id-watch").apply { isDaemon = true; start() }
|
||||
val buffer = ByteArray(16384)
|
||||
|
||||
@@ -22,8 +22,8 @@ object DesktopCatalog {
|
||||
val icon: String, val category: String,
|
||||
)
|
||||
|
||||
fun fetch(url: String = CATALOG_URL): List<Entry>? {
|
||||
val body = Downloader.downloadString(url) ?: return null
|
||||
fun fetch(url: String = CATALOG_URL, cancelled: java.util.function.BooleanSupplier? = null): List<Entry>? {
|
||||
val body = Downloader.downloadString(url, cancelled) ?: return null
|
||||
return try {
|
||||
val json = JSONObject(body)
|
||||
val arr = json.getJSONArray("packages")
|
||||
@@ -71,9 +71,22 @@ object DesktopCatalog {
|
||||
}
|
||||
|
||||
fun resumeInterrupted(context: Context, listener: LinuxRuntimeInstaller.ProgressListener?): String? = synchronized(installLock) {
|
||||
resumeInterrupted(context, null, listener)
|
||||
}
|
||||
|
||||
fun resumeInterrupted(
|
||||
context: Context,
|
||||
cancelled: Downloader.Cancellation?,
|
||||
listener: LinuxRuntimeInstaller.ProgressListener?,
|
||||
): String? = synchronized(installLock) {
|
||||
for (entry in interrupted(context)) {
|
||||
Log.w(TAG, "finishing the interrupted install of ${entry.id} ${entry.version}")
|
||||
install(context, entry, listener)?.let { return it }
|
||||
val problem = if (cancelled == null) {
|
||||
install(context, entry, listener)
|
||||
} else {
|
||||
install(context, entry, cancelled, listener)
|
||||
}
|
||||
if (problem != null) return problem
|
||||
}
|
||||
null
|
||||
}
|
||||
@@ -102,19 +115,27 @@ object DesktopCatalog {
|
||||
!File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/steamapps/appmanifest_4427310.acf").isFile
|
||||
|
||||
const val DESKTOP_ID = "desktop-kde"
|
||||
const val EMULATORS_ID = "emulators"
|
||||
private const val EMULATORS_SCRIPT = "/usr/local/bin/droiddeck-emulators"
|
||||
|
||||
fun desktopEntry(context: Context) = Entry(
|
||||
DESKTOP_ID, context.getString(R.string.content_linux_desktop), 1, BuildConfig.DESKTOP_KDE_TAG, "tar",
|
||||
BuildConfig.DESKTOP_KDE_URL, BuildConfig.DESKTOP_KDE_SHA256, BuildConfig.DESKTOP_KDE_SIZE, "",
|
||||
"", "",
|
||||
)
|
||||
fun desktopEntry(context: Context): Entry {
|
||||
val pack = DesktopPack.info(LinuxRuntime.rootDir(context))
|
||||
return Entry(
|
||||
DESKTOP_ID, context.getString(R.string.content_linux_desktop), 1, pack?.tag ?: BuildConfig.DESKTOP_KDE_TAG, "tar",
|
||||
pack?.url ?: BuildConfig.DESKTOP_KDE_URL, pack?.sha256 ?: BuildConfig.DESKTOP_KDE_SHA256,
|
||||
pack?.size ?: BuildConfig.DESKTOP_KDE_SIZE, "", "", "",
|
||||
)
|
||||
}
|
||||
|
||||
fun desktopInstalled(context: Context): Boolean = desktopInstalled(LinuxRuntime.rootDir(context))
|
||||
|
||||
fun desktopFromPack(root: File): Boolean = DesktopPack.info(root) != null
|
||||
|
||||
fun desktopInstalled(root: File): Boolean =
|
||||
!File(root, DesktopRemoval.PENDING).exists() &&
|
||||
File(root, "usr/bin/kwin_wayland").isFile &&
|
||||
FileUtils.readString(File(root, ".droiddeck-pkg-$DESKTOP_ID"))?.trim() == BuildConfig.DESKTOP_KDE_TAG
|
||||
FileUtils.readString(File(root, ".droiddeck-pkg-$DESKTOP_ID"))?.trim() ==
|
||||
(DesktopPack.info(root)?.tag ?: BuildConfig.DESKTOP_KDE_TAG)
|
||||
|
||||
fun desktopPresent(context: Context): Boolean {
|
||||
val root = LinuxRuntime.rootDir(context)
|
||||
@@ -144,12 +165,19 @@ object DesktopCatalog {
|
||||
}
|
||||
|
||||
fun install(context: Context, entry: Entry, listener: LinuxRuntimeInstaller.ProgressListener?): String? = synchronized(installLock) {
|
||||
installLocked(context, entry, listener)
|
||||
installLocked(context, entry, null, listener)
|
||||
}
|
||||
|
||||
private fun installLocked(context: Context, entry: Entry, listener: LinuxRuntimeInstaller.ProgressListener?): String? {
|
||||
fun install(context: Context, entry: Entry, cancelled: Downloader.Cancellation,
|
||||
listener: LinuxRuntimeInstaller.ProgressListener?): String? = synchronized(installLock) {
|
||||
installLocked(context, entry, cancelled, listener)
|
||||
}
|
||||
|
||||
private fun installLocked(context: Context, entry: Entry, cancelled: Downloader.Cancellation?,
|
||||
listener: LinuxRuntimeInstaller.ProgressListener?): String? {
|
||||
val root = LinuxRuntime.rootDir(context)
|
||||
if (!root.isDirectory) return context.getString(R.string.deskpkg_runtime_missing)
|
||||
if (entry.id == EMULATORS_ID && desktopFromPack(root)) return installEmulators(context, entry, cancelled, listener)
|
||||
if (entry.sha256.isEmpty()) return context.getString(R.string.deskpkg_no_checksum, entry.name)
|
||||
val download = downloadFile(context, entry)
|
||||
val journal = journal(root, entry.id)
|
||||
@@ -166,14 +194,20 @@ object DesktopCatalog {
|
||||
if (!downloaded(download, entry)) {
|
||||
val downloading = context.getString(R.string.user_apps_downloading, entry.name)
|
||||
report.onProgress(LinuxRuntimeInstaller.Step.DOWNLOADING, downloading, 0)
|
||||
val ok = Downloader.downloadFile(entry.url, download, true, entry.sha256) { f ->
|
||||
val progress = java.util.function.Consumer<Float> { f ->
|
||||
report.onProgress(LinuxRuntimeInstaller.Step.DOWNLOADING, downloading, if (f < 0) -1 else Math.round(f * 100f))
|
||||
}
|
||||
if (!ok) return context.getString(R.string.user_apps_download_failed)
|
||||
val ok = if (cancelled == null) {
|
||||
Downloader.downloadFile(entry.url, download, true, entry.sha256, progress)
|
||||
} else {
|
||||
Downloader.downloadFile(entry.url, download, true, entry.sha256, cancelled, progress)
|
||||
}
|
||||
if (!ok || cancelled?.getAsBoolean() == true) return context.getString(R.string.user_apps_download_failed)
|
||||
report.onProgress(LinuxRuntimeInstaller.Step.VERIFYING, context.getString(R.string.rtinst_verifying), -1)
|
||||
val actual = Hashes.sha256(download)
|
||||
if (!entry.sha256.equals(actual, ignoreCase = true)) return context.getString(R.string.deskpkg_checksum_mismatch)
|
||||
}
|
||||
if (cancelled?.getAsBoolean() == true) return context.getString(R.string.user_apps_download_failed)
|
||||
report.onProgress(context.getString(R.string.deskpkg_installing, entry.name), -1)
|
||||
when (entry.kind) {
|
||||
"appimage" -> {
|
||||
@@ -192,11 +226,12 @@ object DesktopCatalog {
|
||||
check(FileUtils.writeString(journal, entryJson(entry).toString())) { "Could not record the package installation" }
|
||||
keepDownload = true
|
||||
marker(context, entry.id).delete()
|
||||
if (entry.id == DESKTOP_ID && desktopFromPack(root)) DesktopPack.prepareInstall(root)
|
||||
if (!LinuxRuntimeInstaller.extract(context, download, root, report)) return context.getString(R.string.deskpkg_extract_failed)
|
||||
}
|
||||
}
|
||||
if (entry.id == DESKTOP_ID) {
|
||||
cleanLegacy(context, report)
|
||||
if (desktopFromPack(root)) DesktopPack.finishInstall(root) else cleanLegacy(context, report)
|
||||
val pending = File(root, DesktopRemoval.PENDING)
|
||||
check(!pending.exists() || pending.delete()) { "Could not finish desktop installation" }
|
||||
}
|
||||
@@ -214,6 +249,47 @@ object DesktopCatalog {
|
||||
}
|
||||
}
|
||||
|
||||
private fun installEmulators(context: Context, entry: Entry, cancelled: Downloader.Cancellation?,
|
||||
listener: LinuxRuntimeInstaller.ProgressListener?): String? {
|
||||
val release = RuntimeInstallService.holdForPackage(context, context.getString(R.string.deskpkg_installing, entry.name))
|
||||
val stop = java.util.concurrent.atomic.AtomicBoolean(false)
|
||||
val finished = java.util.concurrent.atomic.AtomicBoolean(false)
|
||||
cancelled?.let { token ->
|
||||
Thread({
|
||||
try {
|
||||
while (!finished.get() && !stop.get()) {
|
||||
if (token.getAsBoolean()) stop.set(true) else Thread.sleep(200)
|
||||
}
|
||||
} catch (_: InterruptedException) {
|
||||
}
|
||||
}, "emulators-cancel").apply { isDaemon = true; start() }
|
||||
}
|
||||
try {
|
||||
var failure: String? = null
|
||||
val status = GuestCommand.run(context, listOf("/bin/bash", EMULATORS_SCRIPT, "install"), logName = "emulators",
|
||||
cancelled = stop) { line ->
|
||||
when {
|
||||
line.startsWith("== STEP ") -> {
|
||||
val stage = context.getString(R.string.deskpkg_installing, line.removePrefix("== STEP "))
|
||||
RuntimeInstallService.packageProgress(stage, -1)
|
||||
listener?.onProgress(stage, -1)
|
||||
}
|
||||
line.startsWith("== FAIL ") -> failure = line.removePrefix("== FAIL ")
|
||||
}
|
||||
}
|
||||
if (stop.get()) return context.getString(R.string.user_apps_download_failed)
|
||||
if (failure != null || status != 0) return context.getString(R.string.deskpkg_install_failed)
|
||||
check(FileUtils.writeString(marker(context, entry.id), entry.version)) { "Could not finish package installation" }
|
||||
return null
|
||||
} catch (e: Exception) {
|
||||
Log.e(TAG, "install ${entry.id}", e)
|
||||
return e.message ?: context.getString(R.string.deskpkg_install_failed)
|
||||
} finally {
|
||||
finished.set(true)
|
||||
release()
|
||||
}
|
||||
}
|
||||
|
||||
private fun unzipAppImage(zip: File, target: File): Boolean {
|
||||
try {
|
||||
java.util.zip.ZipInputStream(java.io.BufferedInputStream(java.io.FileInputStream(zip))).use { zin ->
|
||||
|
||||
@@ -73,10 +73,42 @@ internal object DesktopFileRemoval {
|
||||
}
|
||||
}
|
||||
|
||||
private val RECORD = Regex("[A-Za-z0-9@._+:-]+")
|
||||
|
||||
fun desktopRecords(root: File): Set<String> {
|
||||
val list = safeFile(root, "usr/share/droiddeck/pacman/desktop-packages.txt") ?: return emptySet()
|
||||
if (!Files.isRegularFile(list.toPath(), NOFOLLOW_LINKS)) return emptySet()
|
||||
return list.readLines().mapNotNull { line ->
|
||||
line.split(' ').takeIf { it.size == 2 }?.let { "${it[0]}-${it[1]}" }?.takeIf { RECORD.matches(it) && it != "." && it != ".." }
|
||||
}.toSet()
|
||||
}
|
||||
|
||||
fun removeRecords(root: File, records: Set<String>) {
|
||||
val lib = File(root, "var/lib/pacman")
|
||||
if (Files.isSymbolicLink(File(root, "var").toPath()) || Files.isSymbolicLink(lib.toPath())) return
|
||||
val local = File(lib, "local")
|
||||
if (!local.isDirectory || Files.isSymbolicLink(local.toPath())) return
|
||||
for (record in records) {
|
||||
if (!RECORD.matches(record) || record == "." || record == "..") continue
|
||||
val dir = File(local, record)
|
||||
if (Files.isSymbolicLink(dir.toPath()) || !dir.isDirectory) continue
|
||||
for (file in dir.listFiles().orEmpty()) {
|
||||
if (Files.isSymbolicLink(file.toPath()) || file.isFile) Files.delete(file.toPath())
|
||||
}
|
||||
if (!dir.delete()) throw IOException("Cannot remove $dir")
|
||||
}
|
||||
for (name in listOf("sync/droiddeck.db", "droiddeck-desktop")) {
|
||||
val file = File(lib, name)
|
||||
if (Files.isSymbolicLink(file.toPath()) || file.isFile) Files.delete(file.toPath())
|
||||
}
|
||||
}
|
||||
|
||||
fun runtimeFiles(root: File): Set<String> = buildSet {
|
||||
val database = File(root, "var/lib/pacman/local")
|
||||
if (!database.isDirectory || Files.isSymbolicLink(database.toPath())) throw IOException("Runtime package database missing")
|
||||
val desktop = desktopRecords(root)
|
||||
for (pkg in database.listFiles().orEmpty()) {
|
||||
if (pkg.name in desktop) continue
|
||||
val files = File(pkg, "files")
|
||||
if (!pkg.isDirectory || Files.isSymbolicLink(pkg.toPath()) || !files.isFile || Files.isSymbolicLink(files.toPath())) continue
|
||||
var inFiles = false
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import com.droiddeck.launcher.core.FileUtils
|
||||
import com.droiddeck.launcher.core.Hashes
|
||||
import java.io.File
|
||||
import java.nio.file.Files
|
||||
import java.nio.file.LinkOption
|
||||
import java.nio.file.Paths
|
||||
import java.nio.file.StandardCopyOption
|
||||
import java.util.zip.GZIPInputStream
|
||||
import org.json.JSONObject
|
||||
|
||||
internal object DesktopPack {
|
||||
const val INFO = "usr/share/droiddeck/desktop-pack.json"
|
||||
const val META = "usr/share/droiddeck/desktop"
|
||||
private const val MANIFEST = "$META/files.tsv.gz"
|
||||
private const val ORIGINALS = "$META/originals"
|
||||
private const val STATUS = "var/lib/dpkg/status"
|
||||
private const val STATUS_BEFORE = "var/lib/dpkg/status.droiddeck"
|
||||
private const val PACK_STATUS = "$META/dpkg-status"
|
||||
|
||||
data class Info(val tag: String, val url: String, val sha256: String, val size: Long)
|
||||
|
||||
data class Entry(val kind: Char, val type: Char, val size: Long, val value: String, val path: String) {
|
||||
companion object {
|
||||
fun parse(line: String): Entry? {
|
||||
val parts = line.split('\t', limit = 5)
|
||||
if (parts.size != 5 || parts[0].length != 1 || parts[1].length != 1) return null
|
||||
return Entry(parts[0][0], parts[1][0], parts[2].toLongOrNull() ?: return null, parts[3], parts[4])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
data class Result(val removed: Int, val restored: Int, val kept: Int)
|
||||
|
||||
fun info(root: File): Info? = runCatching {
|
||||
val json = JSONObject(FileUtils.readString(File(root, INFO)) ?: return null)
|
||||
Info(json.getString("tag"), json.getString("url"), json.getString("sha256"), json.getLong("size"))
|
||||
}.getOrNull()
|
||||
|
||||
fun installed(root: File): Boolean = File(root, MANIFEST).isFile
|
||||
|
||||
fun entries(root: File): List<Entry> =
|
||||
GZIPInputStream(File(root, MANIFEST).inputStream()).bufferedReader().use { reader ->
|
||||
reader.lineSequence().mapNotNull(Entry::parse).toList()
|
||||
}
|
||||
|
||||
fun installedSize(root: File): Long =
|
||||
if (installed(root)) entries(root).filter { it.kind == 'N' && it.type == 'F' }.sumOf { it.size } else 0L
|
||||
|
||||
fun prepareInstall(root: File) {
|
||||
val live = File(root, STATUS)
|
||||
val before = File(root, STATUS_BEFORE)
|
||||
if (!before.exists() && live.isFile) Files.copy(live.toPath(), before.toPath(), StandardCopyOption.COPY_ATTRIBUTES)
|
||||
}
|
||||
|
||||
fun finishInstall(root: File) {
|
||||
for (entry in entries(root).filter { it.kind == 'R' }.sortedByDescending { it.path.length }) {
|
||||
val file = inside(root, entry.path) ?: continue
|
||||
if (entry.type == 'D') file.delete() else Files.deleteIfExists(file.toPath())
|
||||
}
|
||||
val live = File(root, STATUS)
|
||||
val packStatus = File(root, PACK_STATUS)
|
||||
if (live.isFile && !packStatus.exists()) Files.copy(live.toPath(), packStatus.toPath())
|
||||
val before = File(root, STATUS_BEFORE)
|
||||
val runtime = File(File(root, ORIGINALS), STATUS)
|
||||
if (before.isFile && runtime.isFile && live.isFile) {
|
||||
writeStatus(live, mergeStatus(runtime.readText(), packStatus.readText(), before.readText()))
|
||||
}
|
||||
Files.deleteIfExists(before.toPath())
|
||||
}
|
||||
|
||||
internal fun mergeStatus(base: String, target: String, mine: String): String {
|
||||
val from = stanzas(base)
|
||||
val into = LinkedHashMap(stanzas(target))
|
||||
val kept = stanzas(mine)
|
||||
for ((key, stanza) in kept) {
|
||||
if (from[key] != stanza && into[key] == from[key]) into[key] = stanza
|
||||
}
|
||||
for (key in from.keys) {
|
||||
if (key !in kept && into[key] == from[key]) into.remove(key)
|
||||
}
|
||||
return into.values.joinToString("") { it + "\n\n" }
|
||||
}
|
||||
|
||||
private fun stanzas(text: String): Map<String, String> {
|
||||
val out = LinkedHashMap<String, String>()
|
||||
for (stanza in text.split(Regex("\n[ \t]*\n")).map { it.trim('\n') }.filter { it.isNotBlank() }) {
|
||||
val fields = stanza.lines()
|
||||
fun field(name: String) = fields.firstOrNull { it.startsWith("$name:") }?.substringAfter(':')?.trim().orEmpty()
|
||||
out["${field("Package")}:${field("Architecture")}"] = stanza
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
private fun writeStatus(file: File, text: String) {
|
||||
val part = LinuxRuntimeInstaller.partFile(file).toPath()
|
||||
Files.deleteIfExists(part)
|
||||
Files.copy(file.toPath(), part, StandardCopyOption.COPY_ATTRIBUTES)
|
||||
Files.write(part, text.toByteArray(), java.nio.file.StandardOpenOption.TRUNCATE_EXISTING)
|
||||
Files.move(part, file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
|
||||
}
|
||||
|
||||
fun remove(root: File, progress: (Int) -> Unit = {}): Result {
|
||||
val entries = entries(root)
|
||||
var removed = 0
|
||||
var restored = 0
|
||||
var kept = 0
|
||||
val originals = File(root, ORIGINALS)
|
||||
val live = File(root, STATUS)
|
||||
val userStatus = if (live.isFile) live.readText() else null
|
||||
for (entry in entries.filter { it.kind == 'C' || it.kind == 'R' }) {
|
||||
val file = inside(root, entry.path) ?: continue
|
||||
if (entry.type == 'D') {
|
||||
file.mkdirs()
|
||||
continue
|
||||
}
|
||||
if (entry.kind == 'C' && !entry.path.startsWith("var/lib/dpkg/") && !matchesOrMissing(file, entry)) {
|
||||
kept++
|
||||
continue
|
||||
}
|
||||
val source = inside(originals, entry.path) ?: continue
|
||||
val sourcePath = source.toPath()
|
||||
if (!Files.exists(sourcePath, LinkOption.NOFOLLOW_LINKS)) continue
|
||||
file.parentFile?.mkdirs()
|
||||
val part = LinuxRuntimeInstaller.partFile(file).toPath()
|
||||
Files.deleteIfExists(part)
|
||||
if (Files.isSymbolicLink(sourcePath)) Files.createSymbolicLink(part, Files.readSymbolicLink(sourcePath))
|
||||
else Files.copy(sourcePath, part, StandardCopyOption.COPY_ATTRIBUTES)
|
||||
if (Files.isDirectory(file.toPath(), LinkOption.NOFOLLOW_LINKS)) FileUtils.delete(file)
|
||||
Files.move(part, file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
|
||||
restored++
|
||||
}
|
||||
val added = entries.filter { it.kind == 'N' }
|
||||
val directories = ArrayList<File>()
|
||||
added.forEachIndexed { index, entry ->
|
||||
val file = inside(root, entry.path)
|
||||
when {
|
||||
file == null -> kept++
|
||||
entry.type == 'D' -> directories += file
|
||||
matches(file, entry) -> { Files.deleteIfExists(file.toPath()); removed++ }
|
||||
Files.exists(file.toPath(), LinkOption.NOFOLLOW_LINKS) -> kept++
|
||||
}
|
||||
if (index % 2000 == 0) progress(index * 100 / added.size.coerceAtLeast(1))
|
||||
}
|
||||
for (dir in directories.sortedByDescending { it.path.length }) {
|
||||
if (Files.isDirectory(dir.toPath(), LinkOption.NOFOLLOW_LINKS) && dir.list()?.isEmpty() == true) dir.delete()
|
||||
}
|
||||
val packStatus = File(root, PACK_STATUS)
|
||||
if (userStatus != null && packStatus.isFile && live.isFile) {
|
||||
writeStatus(live, mergeStatus(packStatus.readText(), live.readText(), userStatus))
|
||||
}
|
||||
FileUtils.delete(File(root, META))
|
||||
return Result(removed, restored, kept)
|
||||
}
|
||||
|
||||
private fun matchesOrMissing(file: File, entry: Entry) =
|
||||
!Files.exists(file.toPath(), LinkOption.NOFOLLOW_LINKS) || matches(file, entry)
|
||||
|
||||
private fun matches(file: File, entry: Entry): Boolean {
|
||||
val path = file.toPath()
|
||||
return when (entry.type) {
|
||||
'L' -> Files.isSymbolicLink(path) && Files.readSymbolicLink(path).toString() == entry.value
|
||||
'F' -> Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS) && file.length() == entry.size &&
|
||||
Hashes.sha256(file).equals(entry.value, ignoreCase = true)
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
|
||||
internal fun inside(root: File, path: String): File? {
|
||||
if (path.isEmpty() || path.startsWith("/")) return null
|
||||
val normal = Paths.get(path).normalize()
|
||||
if (normal.toString().isEmpty() || normal.startsWith("..")) return null
|
||||
val parent = normal.parent
|
||||
val dir = if (parent == null) root else com.droiddeck.launcher.core.ArchivePaths.inside(root, parent.toString()) ?: return null
|
||||
return File(dir, normal.fileName.toString())
|
||||
}
|
||||
}
|
||||
@@ -18,8 +18,11 @@ internal object DesktopRemoval {
|
||||
private fun protected(context: Context, root: File) =
|
||||
DesktopFileRemoval.runtimeFiles(root) + lines(context, "emulators-keep.txt.gzip")
|
||||
|
||||
fun installedSize(context: Context): Long =
|
||||
lines(context, "kde-remove.tsv.gzip").sumOf { line -> line.split('\t').getOrNull(1)?.toLongOrNull() ?: 0L }
|
||||
fun installedSize(context: Context): Long {
|
||||
val root = LinuxRuntime.rootDir(context)
|
||||
if (DesktopPack.info(root) != null) return DesktopPack.installedSize(root)
|
||||
return lines(context, "kde-remove.tsv.gzip").sumOf { line -> line.split('\t').getOrNull(1)?.toLongOrNull() ?: 0L }
|
||||
}
|
||||
|
||||
fun cleanLegacy(context: Context, listener: LinuxRuntimeInstaller.ProgressListener? = null) {
|
||||
val root = LinuxRuntime.rootDir(context)
|
||||
@@ -40,8 +43,12 @@ internal object DesktopRemoval {
|
||||
Log.i("DesktopRemoval", "LXQt: $result")
|
||||
}
|
||||
|
||||
fun remove(context: Context, listener: LinuxRuntimeInstaller.ProgressListener): String? = try {
|
||||
fun remove(context: Context, listener: LinuxRuntimeInstaller.ProgressListener): String? {
|
||||
val root = LinuxRuntime.rootDir(context)
|
||||
return if (DesktopPack.info(root) != null) removePack(context, root, listener) else removeLegacy(context, root, listener)
|
||||
}
|
||||
|
||||
private fun removeLegacy(context: Context, root: File, listener: LinuxRuntimeInstaller.ProgressListener): String? = try {
|
||||
val pending = File(root, PENDING)
|
||||
val marker = File(root, ".droiddeck-pkg-${DesktopCatalog.DESKTOP_ID}")
|
||||
val installing = DesktopCatalog.interrupted(root).firstOrNull { it.id == DesktopCatalog.DESKTOP_ID }
|
||||
@@ -50,12 +57,14 @@ internal object DesktopRemoval {
|
||||
check(version in versions && (installing == null || installing.version in versions)) { context.getString(R.string.desktop_removal_unknown) }
|
||||
val entries = lines(context, "kde-remove.tsv.gzip").map(DesktopFileRemoval.Entry::parse)
|
||||
val keep = protected(context, root)
|
||||
val records = DesktopFileRemoval.desktopRecords(root)
|
||||
cleanLegacy(context, listener)
|
||||
FileUtils.writeString(pending, version!!)
|
||||
check(FileUtils.readString(pending)?.trim() == version) { "Could not reserve desktop removal" }
|
||||
if (marker.exists() && !marker.delete()) error("Could not clear desktop marker")
|
||||
val removing = context.getString(R.string.desktop_removing)
|
||||
val result = DesktopFileRemoval.remove(root, entries, keep) { listener.onProgress(removing, it) }
|
||||
DesktopFileRemoval.removeRecords(root, records)
|
||||
for ((asset, path) in com.droiddeck.launcher.session.SessionFiles.DESKTOP_FILES) {
|
||||
val target = DesktopFileRemoval.safeFile(root, path) ?: continue
|
||||
if (!isRegularFile(target)) continue
|
||||
@@ -74,5 +83,29 @@ internal object DesktopRemoval {
|
||||
e.message ?: context.getString(R.string.deskpkg_install_failed)
|
||||
}
|
||||
|
||||
private fun removePack(context: Context, root: File, listener: LinuxRuntimeInstaller.ProgressListener): String? = try {
|
||||
val pending = File(root, PENDING)
|
||||
val marker = File(root, ".droiddeck-pkg-${DesktopCatalog.DESKTOP_ID}")
|
||||
FileUtils.writeString(pending, DesktopPack.info(root)!!.tag)
|
||||
check(pending.isFile) { "Could not reserve desktop removal" }
|
||||
if (marker.exists() && !marker.delete()) error("Could not clear desktop marker")
|
||||
val removing = context.getString(R.string.desktop_removing)
|
||||
for ((_, path) in com.droiddeck.launcher.session.SessionFiles.DESKTOP_FILES) {
|
||||
DesktopFileRemoval.safeFile(root, path)?.takeIf { isRegularFile(it) }?.delete()
|
||||
}
|
||||
for (path in DESKTOP_STATE) DesktopPack.inside(root, path)?.let(FileUtils::delete)
|
||||
val result = if (DesktopPack.installed(root)) DesktopPack.remove(root) { listener.onProgress(removing, it) } else null
|
||||
DesktopCatalog.discardDesktopInstall(context)
|
||||
if (!pending.delete()) error("Could not finish desktop removal")
|
||||
Log.i("DesktopRemoval", "pack: $result")
|
||||
listener.onProgress(context.getString(R.string.desktop_removed), 100)
|
||||
null
|
||||
} catch (e: Exception) {
|
||||
Log.e("DesktopRemoval", "remove", e)
|
||||
e.message ?: context.getString(R.string.deskpkg_install_failed)
|
||||
}
|
||||
|
||||
private val DESKTOP_STATE = listOf("var/lib/PackageKit", "var/cache/swcatalog")
|
||||
|
||||
private fun isRegularFile(file: File) = java.nio.file.Files.isRegularFile(file.toPath(), java.nio.file.LinkOption.NOFOLLOW_LINKS)
|
||||
}
|
||||
@@ -1,18 +1,18 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.IntentFilter
|
||||
import android.app.Notification
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.database.ContentObserver
|
||||
import android.media.AudioManager
|
||||
import android.net.Uri
|
||||
import android.os.FileObserver
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.SystemClock
|
||||
import android.provider.Settings
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.core.SessionPart
|
||||
@@ -29,14 +29,16 @@ class DeviceControlsComponent(context: Context, root: File, private val activity
|
||||
private val directory = directory(root)
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private var running = false
|
||||
private var pendingBrightness: Float? = null
|
||||
private var permissionRequestAt = -5_000L
|
||||
private var permissionNotified = false
|
||||
private var previous = ""
|
||||
private var revision = 0L
|
||||
init { prepareBacklight(context, root) }
|
||||
private val observer = object : ContentObserver(handler) {
|
||||
override fun onChange(selfChange: Boolean) { if (running) publish() }
|
||||
}
|
||||
private val volumeSteps = object : BroadcastReceiver() {
|
||||
override fun onReceive(context: Context, intent: Intent) { if (running) publishVolume() }
|
||||
}
|
||||
private val requests = object : FileObserver(directory.path, CLOSE_WRITE or MOVED_TO) {
|
||||
override fun onEvent(event: Int, path: String?) {
|
||||
if (path in REQUESTS) handler.post { if (running) consume() }
|
||||
@@ -46,25 +48,29 @@ class DeviceControlsComponent(context: Context, root: File, private val activity
|
||||
override fun run() {
|
||||
if (!running) return
|
||||
consume()
|
||||
pendingBrightness?.let { value ->
|
||||
if (Settings.System.canWrite(context)) {
|
||||
pendingBrightness = null
|
||||
context.getSystemService(NotificationManager::class.java).cancel(PERMISSION_NOTIFICATION)
|
||||
brightness(value)
|
||||
}
|
||||
}
|
||||
if (permissionNotified && Settings.System.canWrite(context))
|
||||
context.getSystemService(NotificationManager::class.java).cancel(PERMISSION_NOTIFICATION)
|
||||
publish()
|
||||
handler.postDelayed(this, 250)
|
||||
}
|
||||
}
|
||||
|
||||
fun publish(force: Boolean = false) {
|
||||
private fun publishVolume() {
|
||||
try {
|
||||
directory.mkdirs()
|
||||
val level = audio.getStreamVolume(AudioManager.STREAM_MUSIC)
|
||||
val maximum = audio.getStreamMaxVolume(AudioManager.STREAM_MUSIC).coerceAtLeast(1)
|
||||
val muted = audio.isStreamMute(AudioManager.STREAM_MUSIC)
|
||||
write("volume.state", "$level $maximum ${if (muted) 1 else 0}\n")
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Could not publish Android volume", e)
|
||||
}
|
||||
}
|
||||
|
||||
fun publish(force: Boolean = false) {
|
||||
publishVolume()
|
||||
try {
|
||||
directory.mkdirs()
|
||||
val value = Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS, 128)
|
||||
write("backlight/droiddeck/brightness", "$value\n")
|
||||
write("backlight/droiddeck/actual_brightness", "$value\n")
|
||||
@@ -86,8 +92,13 @@ class DeviceControlsComponent(context: Context, root: File, private val activity
|
||||
File(directory, "$it.processing").delete()
|
||||
}
|
||||
running = true
|
||||
permissionNotified = false
|
||||
context.contentResolver.registerContentObserver(Settings.System.CONTENT_URI, true, observer)
|
||||
requests.startWatching()
|
||||
context.registerReceiver(volumeSteps, IntentFilter().apply {
|
||||
addAction(VOLUME_CHANGED_ACTION)
|
||||
addAction(STREAM_MUTE_CHANGED_ACTION)
|
||||
}, null, handler)
|
||||
refresh.run()
|
||||
}
|
||||
}
|
||||
@@ -97,8 +108,8 @@ class DeviceControlsComponent(context: Context, root: File, private val activity
|
||||
running = false
|
||||
handler.removeCallbacks(refresh)
|
||||
requests.stopWatching()
|
||||
try { context.unregisterReceiver(volumeSteps) } catch (e: IllegalArgumentException) { }
|
||||
context.contentResolver.unregisterContentObserver(observer)
|
||||
pendingBrightness = null
|
||||
context.getSystemService(NotificationManager::class.java).cancel(PERMISSION_NOTIFICATION)
|
||||
}
|
||||
}
|
||||
@@ -134,13 +145,13 @@ class DeviceControlsComponent(context: Context, root: File, private val activity
|
||||
|
||||
private fun brightness(value: Float) {
|
||||
if (!Settings.System.canWrite(context)) {
|
||||
pendingBrightness = value
|
||||
val now = SystemClock.elapsedRealtime()
|
||||
if (now - permissionRequestAt >= 5_000) {
|
||||
permissionRequestAt = now
|
||||
if (!permissionNotified) {
|
||||
permissionNotified = true
|
||||
try {
|
||||
val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS,
|
||||
Uri.parse("package:${context.packageName}")).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
val intent = Intent(context, com.droiddeck.launcher.FrontEndActivity::class.java)
|
||||
.setAction(com.droiddeck.launcher.core.SteamIntegration.ACTION_SETUP)
|
||||
.putExtra(com.droiddeck.launcher.core.SteamIntegration.EXTRA_FEATURE, "BRIGHTNESS")
|
||||
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||
val manager = context.getSystemService(NotificationManager::class.java)
|
||||
manager.createNotificationChannel(NotificationChannel(PERMISSION_CHANNEL,
|
||||
context.getString(R.string.brightness_permission_title), NotificationManager.IMPORTANCE_DEFAULT))
|
||||
@@ -150,7 +161,8 @@ class DeviceControlsComponent(context: Context, root: File, private val activity
|
||||
.setContentTitle(context.getString(R.string.brightness_permission_title))
|
||||
.setContentText(context.getString(R.string.brightness_permission_text))
|
||||
.setContentIntent(action).setOnlyAlertOnce(true).setAutoCancel(true).build())
|
||||
if (activityVisible()) context.startActivity(intent)
|
||||
if (activityVisible()) android.widget.Toast.makeText(context, R.string.integration_brightness_needed,
|
||||
android.widget.Toast.LENGTH_LONG).show()
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Could not open brightness permission", e)
|
||||
}
|
||||
@@ -177,6 +189,9 @@ class DeviceControlsComponent(context: Context, root: File, private val activity
|
||||
|
||||
companion object {
|
||||
private const val TAG = "DeviceControls"
|
||||
// AudioService sends these on every stream step; the Settings observer and 250 ms poll lag a held volume key.
|
||||
private const val VOLUME_CHANGED_ACTION = "android.media.VOLUME_CHANGED_ACTION"
|
||||
private const val STREAM_MUTE_CHANGED_ACTION = "android.media.STREAM_MUTE_CHANGED_ACTION"
|
||||
private const val PERMISSION_CHANNEL = "brightness_permission"
|
||||
private const val PERMISSION_NOTIFICATION = 0x4442
|
||||
private val REQUESTS = setOf("brightness.request", "volume.request", "mute.request")
|
||||
|
||||
@@ -43,7 +43,7 @@ object GuestCommand {
|
||||
val fastPathKey = if (fastPath && !fakeRoot && linkDir == null && ProotFastPath.enabled(context)) ProotFastPath.key(root, binds) else null
|
||||
cmd += listOf(
|
||||
"/usr/bin/env", "-i", "HOME=/root", "USER=root", "LANG=C.UTF-8",
|
||||
"PATH=/usr/local/bin:/usr/bin:/bin", "XDG_RUNTIME_DIR=${LinuxRuntime.GUEST_RUNTIME_DIR}",
|
||||
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games", "XDG_RUNTIME_DIR=${LinuxRuntime.GUEST_RUNTIME_DIR}",
|
||||
"XDG_DATA_HOME=/root/.local/share", "FLATPAK_BWRAP=${FlatpakManager.BWRAP}",
|
||||
"DROIDDECK_BWRAP_SOCKET=${BwrapSpawner.socket(context)}",
|
||||
"XDG_DATA_DIRS=/root/.local/share/flatpak/exports/share:/usr/local/share:/usr/share",
|
||||
|
||||
@@ -113,12 +113,16 @@ public final class LinuxRuntime {
|
||||
}
|
||||
|
||||
public static boolean isInstalled(Context context) {
|
||||
return hasRootfs(context) && (patchedProot(context) || rootfsProotReady(context));
|
||||
}
|
||||
|
||||
/** The rootfs alone: enough to read the game library, while the proot pack can still be downloading. */
|
||||
public static boolean hasRootfs(Context context) {
|
||||
if (LinuxRuntimeInstaller.isRemoving() || LinuxRuntimeInstaller.hasRemovalPending(context)) return false;
|
||||
File root = rootDir(context);
|
||||
return new File(root, "usr/bin/gamescope").isFile()
|
||||
return (new File(root, "usr/bin/gamescope").isFile() || new File(root, "usr/games/gamescope").isFile())
|
||||
&& (new File(root, SESSION_SCRIPT.substring(1)).isFile()
|
||||
|| new File(root, LegacyNames.SESSION_SCRIPT.substring(1)).isFile())
|
||||
&& (patchedProot(context) || rootfsProotReady(context));
|
||||
|| new File(root, LegacyNames.SESSION_SCRIPT.substring(1)).isFile());
|
||||
}
|
||||
|
||||
public static File vulkanIcd(Context context) {
|
||||
@@ -364,9 +368,9 @@ public final class LinuxRuntime {
|
||||
}
|
||||
|
||||
public static String cpuTempSource() {
|
||||
for (java.util.Map.Entry<String, File> e : new java.util.TreeMap<>(thermalZones()).entrySet()) {
|
||||
File temp = new File(e.getValue(), "temp");
|
||||
if (e.getKey().contains("cpu") && !e.getKey().contains("gpu") && temp.canRead()) return temp.getPath();
|
||||
for (File zone : cpuTempZones()) {
|
||||
File temp = new File(zone, "temp");
|
||||
if (temp.canRead()) return temp.getPath();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -376,7 +380,7 @@ public final class LinuxRuntime {
|
||||
return firstReadable(kgsl + "temp", kgsl + "devfreq/temp", thermalZone("gpu"));
|
||||
}
|
||||
|
||||
private static String gpuLoadSource() {
|
||||
public static String gpuLoadSource() {
|
||||
String kgsl = "/sys/class/kgsl/kgsl-3d0/";
|
||||
return firstReadable(kgsl + "gpu_busy_percentage", kgsl + "devfreq/gpu_load");
|
||||
}
|
||||
@@ -390,7 +394,7 @@ public final class LinuxRuntime {
|
||||
"/sys/devices/platform/soc@0/3d00000.gpu/devfreq/3d00000.gpu/cur_freq"},
|
||||
{gpuTemp, "/sys/class/thermal/thermal_zone28/temp"},
|
||||
{gpuTemp, "/sys/class/thermal/thermal_zone26/temp"},
|
||||
{thermalZone("ddr"), "/sys/class/thermal/thermal_zone22/temp"},
|
||||
{ddrTempSource(), "/sys/class/thermal/thermal_zone22/temp"},
|
||||
};
|
||||
for (String[] stat : stats) {
|
||||
boolean fed = false;
|
||||
@@ -407,6 +411,36 @@ public final class LinuxRuntime {
|
||||
return path != null ? path : "none";
|
||||
}
|
||||
|
||||
private static String ddrTempSource() {
|
||||
return thermalZone("ddr");
|
||||
}
|
||||
|
||||
// MangoHud reads the GPU and DDR temperatures from these zone numbers (bindAdrenoStats). On phones
|
||||
// where they are CPU zones, their type follows the temperature put there, so they stay out of the
|
||||
// CPU average.
|
||||
private static java.util.Map<String, String> replacedZoneTypes() {
|
||||
java.util.Map<String, String> replaced = new java.util.HashMap<>();
|
||||
if (gpuTempSource() != null) {
|
||||
replaced.put("thermal_zone28", "gpu-thermal");
|
||||
replaced.put("thermal_zone26", "gpu-thermal");
|
||||
}
|
||||
if (ddrTempSource() != null) replaced.put("thermal_zone22", "ddr-thermal");
|
||||
return replaced;
|
||||
}
|
||||
|
||||
/** The zones the session's MangoHud averages for the CPU temperature (all typed cpuN-thermal there). */
|
||||
public static List<File> cpuTempZones() {
|
||||
java.util.Map<String, String> replaced = replacedZoneTypes();
|
||||
List<File> zones = new ArrayList<>();
|
||||
for (java.util.Map.Entry<String, File> zone : new java.util.TreeMap<>(thermalZones()).entrySet()) {
|
||||
String type = zone.getKey();
|
||||
if (type.contains("cpu") && !type.contains("gpu") && !replaced.containsKey(zone.getValue().getName())) {
|
||||
zones.add(zone.getValue());
|
||||
}
|
||||
}
|
||||
return zones;
|
||||
}
|
||||
|
||||
private static void bindCpuTemps(List<String> cmd, File root) {
|
||||
File name = new File(root, "etc/droiddeck/cpu-thermal-type");
|
||||
try {
|
||||
@@ -414,9 +448,18 @@ public final class LinuxRuntime {
|
||||
} catch (IOException e) {
|
||||
return;
|
||||
}
|
||||
java.util.Map<String, String> replaced = replacedZoneTypes();
|
||||
for (java.util.Map.Entry<String, File> zone : thermalZones().entrySet()) {
|
||||
String type = zone.getKey();
|
||||
if (type.contains("cpu") && !type.contains("gpu") && !type.matches("cpu\\d-(top-)?thermal")) {
|
||||
String other = replaced.get(zone.getValue().getName());
|
||||
if (other != null) {
|
||||
File typeFile = new File(root, "etc/droiddeck/" + other + "-type");
|
||||
try {
|
||||
if (!typeFile.isFile()) Files.write(typeFile.toPath(), (other + "\n").getBytes(StandardCharsets.US_ASCII));
|
||||
bind(cmd, typeFile.getPath() + ":" + new File(zone.getValue(), "type").getPath());
|
||||
} catch (IOException ignored) {
|
||||
}
|
||||
} else if (type.contains("cpu") && !type.contains("gpu") && !type.matches("cpu\\d-(top-)?thermal")) {
|
||||
bind(cmd, name.getPath() + ":" + new File(zone.getValue(), "type").getPath());
|
||||
}
|
||||
}
|
||||
@@ -471,12 +514,72 @@ public final class LinuxRuntime {
|
||||
+ "\\" + host.version + "\\" + host.machine + "\\localdomain\\-1\\";
|
||||
}
|
||||
|
||||
public static void writeAccounts(Context context) throws IOException {
|
||||
public static synchronized void writeAccounts(Context context) throws IOException {
|
||||
File root = rootDir(context);
|
||||
int uid = Process.myUid();
|
||||
Files.write(new File(root, "etc/passwd").toPath(),
|
||||
("root:x:" + uid + ":" + uid + ":root:/root:/bin/bash\n").getBytes(StandardCharsets.UTF_8));
|
||||
Files.write(new File(root, "etc/group").toPath(),
|
||||
("root:x:" + uid + ":\n").getBytes(StandardCharsets.UTF_8));
|
||||
mergeAccounts(new File(root, "etc/passwd"), 2,
|
||||
"root:x:" + uid + ":" + uid + ":root:/root:/bin/bash", "root:x:0:0:root:/root:/bin/bash", uid);
|
||||
mergeAccounts(new File(root, "etc/group"), 2,
|
||||
"root:x:" + uid + ":", "root:x:0:", uid);
|
||||
File group = new File(root, "etc/group");
|
||||
String groups = new String(Files.readAllBytes(group.toPath()), StandardCharsets.UTF_8);
|
||||
writeIfChanged(group, groups, withStorageGroups(groups));
|
||||
}
|
||||
|
||||
private static final String[][] STORAGE_GROUPS = {
|
||||
{"sdcard_rw", "1015"}, {"media_rw", "1023"}, {"everybody", "9997"}};
|
||||
|
||||
static String withStorageGroups(String groups) {
|
||||
StringBuilder out = new StringBuilder();
|
||||
List<String> present = new ArrayList<>();
|
||||
for (String line : groups.split("\n")) {
|
||||
if (line.trim().isEmpty()) continue;
|
||||
String[] fields = line.split(":", -1);
|
||||
if (fields.length >= 4) {
|
||||
for (String[] storage : STORAGE_GROUPS) {
|
||||
if (fields[0].equals(storage[0])) present.add(storage[0]);
|
||||
if (!fields[2].equals(storage[1])) continue;
|
||||
present.add(storage[0]);
|
||||
if (!java.util.Arrays.asList(fields[3].split(",")).contains("root")) {
|
||||
fields[3] = fields[3].isEmpty() ? "root" : fields[3] + ",root";
|
||||
line = String.join(":", fields);
|
||||
}
|
||||
}
|
||||
}
|
||||
out.append(line).append('\n');
|
||||
}
|
||||
for (String[] storage : STORAGE_GROUPS) {
|
||||
if (!present.contains(storage[0])) {
|
||||
out.append(storage[0]).append(":x:").append(storage[1]).append(":root\n");
|
||||
}
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
|
||||
static String mergedAccounts(String existing, int idField, String own, String zero, int uid) {
|
||||
StringBuilder out = new StringBuilder(own).append('\n').append(zero).append('\n');
|
||||
if (existing == null) return out.toString();
|
||||
String ownId = Integer.toString(uid);
|
||||
for (String line : existing.split("\n")) {
|
||||
if (line.trim().isEmpty()) continue;
|
||||
String[] fields = line.split(":", -1);
|
||||
if (fields.length <= idField) continue;
|
||||
if (fields[0].equals("root") || fields[idField].equals("0") || fields[idField].equals(ownId)) continue;
|
||||
out.append(line).append('\n');
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
|
||||
private static void mergeAccounts(File file, int idField, String own, String zero, int uid) throws IOException {
|
||||
String existing = file.isFile() ? new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8) : null;
|
||||
writeIfChanged(file, existing, mergedAccounts(existing, idField, own, zero, uid));
|
||||
}
|
||||
|
||||
private static void writeIfChanged(File file, String existing, String merged) throws IOException {
|
||||
if (merged.equals(existing)) return;
|
||||
File staged = File.createTempFile(file.getName(), ".staged", file.getParentFile());
|
||||
Files.write(staged.toPath(), merged.getBytes(StandardCharsets.UTF_8));
|
||||
Files.move(staged.toPath(), file.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING,
|
||||
java.nio.file.StandardCopyOption.ATOMIC_MOVE);
|
||||
}
|
||||
}
|
||||
@@ -35,7 +35,7 @@ public final class LinuxRuntimeInstaller {
|
||||
private static final String TAG = "LinuxRuntimeInstaller";
|
||||
|
||||
public static final String CATALOG_URL =
|
||||
"https://raw.githubusercontent.com/Droid-Deck/DroidDeck-Components/main/linuxfs.json";
|
||||
"https://raw.githubusercontent.com/Droid-Deck/DroidDeck-Components/main/linuxfs-ubuntu.json";
|
||||
|
||||
private static final String VERSION_FILE = ".version";
|
||||
|
||||
@@ -88,8 +88,20 @@ public final class LinuxRuntimeInstaller {
|
||||
return v == null ? null : v.trim();
|
||||
}
|
||||
|
||||
private static String catalogUrl() {
|
||||
if (!com.droiddeck.launcher.BuildConfig.DEBUG) return CATALOG_URL;
|
||||
try {
|
||||
Object value = Class.forName("android.os.SystemProperties").getMethod("get", String.class)
|
||||
.invoke(null, "debug.droiddeck.linuxfs");
|
||||
if (value instanceof String && ((String) value).startsWith("http")) return (String) value;
|
||||
} catch (ReflectiveOperationException e) {
|
||||
Log.w(TAG, "catalog override: " + e);
|
||||
}
|
||||
return CATALOG_URL;
|
||||
}
|
||||
|
||||
public static Release fetchRelease() {
|
||||
String body = Downloader.downloadString(CATALOG_URL);
|
||||
String body = Downloader.downloadString(catalogUrl());
|
||||
if (body == null || body.isEmpty()) return null;
|
||||
try {
|
||||
JSONObject json = new JSONObject(body);
|
||||
@@ -292,7 +304,7 @@ public final class LinuxRuntimeInstaller {
|
||||
recoverInterruptedSwap(root, staging, old);
|
||||
if (!discard(staging, null) || !staging.mkdirs()) return false;
|
||||
if (listener != null) listener.onProgress(context.getString(R.string.rtinst_extracting), -1);
|
||||
if (!extract(context, archive, staging, listener)) {
|
||||
if (!extract(context, archive, staging, root, listener)) {
|
||||
RuntimeFileTree.delete(staging, null);
|
||||
return false;
|
||||
}
|
||||
@@ -346,7 +358,11 @@ public final class LinuxRuntimeInstaller {
|
||||
return false;
|
||||
}
|
||||
new File(root, CARRY_MARKER).delete();
|
||||
try { RuntimeFileTree.dropStaleState(root); }
|
||||
catch (IOException e) { Log.w(TAG, "could not clear caches left by the previous runtime", e); }
|
||||
discard(old, null);
|
||||
try { com.droiddeck.launcher.session.SessionFiles.INSTANCE.stage(context, root, false); }
|
||||
catch (Exception e) { Log.w(TAG, "could not stage the session files into the new runtime", e); }
|
||||
return LinuxRuntime.isInstalled(context);
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, "install", e);
|
||||
@@ -513,6 +529,10 @@ public final class LinuxRuntimeInstaller {
|
||||
// Packages extract over the live runtime and their archives list a link before the file it
|
||||
// names, so a kill mid-way must leave neither a truncated file nor a link to a missing one.
|
||||
public static boolean extract(Context context, File archive, File destination, ProgressListener listener) {
|
||||
return extract(context, archive, destination, destination, listener);
|
||||
}
|
||||
|
||||
static boolean extract(Context context, File archive, File destination, File linkRoot, ProgressListener listener) {
|
||||
long entries = 0;
|
||||
String extracting = context.getString(R.string.rtinst_extracting);
|
||||
java.util.LinkedHashMap<File, String> links = new java.util.LinkedHashMap<>();
|
||||
@@ -537,7 +557,7 @@ public final class LinuxRuntimeInstaller {
|
||||
links.remove(file);
|
||||
links.put(file, entry.getLinkName());
|
||||
} else if (entry.isLink()) {
|
||||
File target = ArchivePaths.inside(destination, entry.getLinkName());
|
||||
File target = hardLinkTarget(destination, entry.getLinkName());
|
||||
if (target == null) {
|
||||
Log.w(TAG, "skipping hard link outside the rootfs: " + entry.getLinkName());
|
||||
continue;
|
||||
@@ -548,11 +568,11 @@ public final class LinuxRuntimeInstaller {
|
||||
try {
|
||||
Files.createLink(part.toPath(), target.toPath());
|
||||
} catch (IOException | UnsupportedOperationException e) {
|
||||
if (target.isFile()) {
|
||||
if (!l2sLink(target, part, destination, linkRoot) && target.isFile()) {
|
||||
Files.copy(target.toPath(), part.toPath(), StandardCopyOption.REPLACE_EXISTING);
|
||||
}
|
||||
}
|
||||
if (part.exists()) place(part, file);
|
||||
if (Files.exists(part.toPath(), java.nio.file.LinkOption.NOFOLLOW_LINKS)) place(part, file);
|
||||
} else if (entry.isFile()) {
|
||||
links.remove(file);
|
||||
File part = partFile(file);
|
||||
@@ -589,6 +609,67 @@ public final class LinuxRuntimeInstaller {
|
||||
}
|
||||
}
|
||||
|
||||
static File hardLinkTarget(File destination, String name) throws IOException {
|
||||
java.nio.file.Path path = java.nio.file.Paths.get(name).normalize();
|
||||
java.nio.file.Path last = path.getFileName();
|
||||
if (last == null || last.toString().isEmpty() || last.toString().equals("..")) return null;
|
||||
java.nio.file.Path parent = path.getParent();
|
||||
File dir = parent == null ? destination : ArchivePaths.inside(destination, parent.toString());
|
||||
return dir == null ? null : new File(dir, last.toString());
|
||||
}
|
||||
|
||||
private static final String L2S = ".l2s.";
|
||||
|
||||
static boolean l2sLink(File target, File link) {
|
||||
return l2sLink(target, link, null, null);
|
||||
}
|
||||
|
||||
static boolean l2sLink(File target, File link, File tree, File linkTree) {
|
||||
java.nio.file.Path here = tree == null ? null : tree.toPath().toAbsolutePath().normalize();
|
||||
java.nio.file.Path there = linkTree == null ? here : linkTree.toPath().toAbsolutePath().normalize();
|
||||
java.util.function.UnaryOperator<java.nio.file.Path> shown = path -> {
|
||||
java.nio.file.Path p = path.toAbsolutePath().normalize();
|
||||
return here == null || !p.startsWith(here) ? p : there.resolve(here.relativize(p));
|
||||
};
|
||||
java.util.function.UnaryOperator<java.nio.file.Path> actual = path -> {
|
||||
java.nio.file.Path p = path.toAbsolutePath().normalize();
|
||||
return there == null || !p.startsWith(there) ? p : here.resolve(there.relativize(p));
|
||||
};
|
||||
try {
|
||||
java.nio.file.Path original = target.toPath().toAbsolutePath().normalize();
|
||||
java.nio.file.Path intermediate;
|
||||
if (Files.isSymbolicLink(original)) {
|
||||
intermediate = actual.apply(Files.readSymbolicLink(original));
|
||||
if (!intermediate.getFileName().toString().startsWith(L2S) || !Files.isSymbolicLink(intermediate)) return false;
|
||||
java.nio.file.Path fin = actual.apply(Files.readSymbolicLink(intermediate));
|
||||
String name = fin.getFileName().toString();
|
||||
int count = Integer.parseInt(name.substring(name.length() - 4)) + 1;
|
||||
java.nio.file.Path next = fin.resolveSibling(name.substring(0, name.length() - 4) + String.format(java.util.Locale.ROOT, "%04d", count));
|
||||
Files.move(fin, next, StandardCopyOption.ATOMIC_MOVE);
|
||||
Files.delete(intermediate);
|
||||
Files.createSymbolicLink(intermediate, shown.apply(next));
|
||||
} else {
|
||||
if (!Files.isRegularFile(original, java.nio.file.LinkOption.NOFOLLOW_LINKS)) return false;
|
||||
java.nio.file.Path dir = original.getParent();
|
||||
String base = L2S + original.getFileName();
|
||||
int suffix = 1;
|
||||
do {
|
||||
intermediate = dir.resolve(base + String.format(java.util.Locale.ROOT, "%04d", suffix++));
|
||||
} while (Files.exists(intermediate, java.nio.file.LinkOption.NOFOLLOW_LINKS) && suffix < 1000);
|
||||
java.nio.file.Path fin = dir.resolve(intermediate.getFileName() + ".0002");
|
||||
Files.move(original, fin, StandardCopyOption.ATOMIC_MOVE);
|
||||
Files.createSymbolicLink(intermediate, shown.apply(fin));
|
||||
Files.createSymbolicLink(original, shown.apply(intermediate));
|
||||
}
|
||||
Files.deleteIfExists(link.toPath());
|
||||
Files.createSymbolicLink(link.toPath(), shown.apply(intermediate));
|
||||
return true;
|
||||
} catch (IOException | RuntimeException e) {
|
||||
Log.w(TAG, "l2s link " + link + " -> " + target + ": " + e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static File partFile(File file) {
|
||||
return new File(file.getParentFile(), ".dd-part-" + Integer.toHexString(file.getName().hashCode()));
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import android.content.Context
|
||||
import android.os.Build
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
import java.io.File
|
||||
@@ -37,9 +38,10 @@ object ProotFastPath {
|
||||
|
||||
fun hostEnv(key: String): Pair<String, String> = "PROOT_FASTPATH" to key
|
||||
|
||||
fun guestEnv(root: File, binds: List<String>, key: String): List<String> = listOf(
|
||||
fun guestEnv(root: File, binds: List<String>, key: String, sdk: Int = Build.VERSION.SDK_INT): List<String> = listOf(
|
||||
"PROOT_FP_ROOT=" + root.path,
|
||||
"PROOT_FP_BINDS=" + binds.joinToString("|"),
|
||||
"PROOT_FP_KEY=$key",
|
||||
"PROOT_FP_ANDROID_API=$sdk",
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,201 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import android.content.Context
|
||||
import android.net.LocalServerSocket
|
||||
import android.net.LocalSocket
|
||||
import android.os.ParcelFileDescriptor
|
||||
import android.os.Process
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.core.HostProcess
|
||||
import com.droiddeck.launcher.session.OrphanReaper
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
import org.json.JSONObject
|
||||
import java.io.DataInputStream
|
||||
import java.io.DataOutputStream
|
||||
import java.io.File
|
||||
import java.io.FileDescriptor
|
||||
import java.io.FileInputStream
|
||||
import java.io.FileOutputStream
|
||||
import java.io.IOException
|
||||
import java.io.InputStream
|
||||
import java.io.OutputStream
|
||||
import java.util.concurrent.atomic.AtomicInteger
|
||||
|
||||
object RootSpawner {
|
||||
private const val TAG = "RootSpawner"
|
||||
fun socket(context: Context): String = "${context.packageName}.root"
|
||||
private val seq = AtomicInteger()
|
||||
@Volatile private var server: LocalServerSocket? = null
|
||||
|
||||
@Synchronized
|
||||
fun start(context: Context) {
|
||||
if (server != null) return
|
||||
val app = context.applicationContext
|
||||
val name = socket(app)
|
||||
val socket = try {
|
||||
LocalServerSocket(name)
|
||||
} catch (e: IOException) {
|
||||
Log.e(TAG, "cannot listen on $name", e)
|
||||
return
|
||||
}
|
||||
server = socket
|
||||
Thread({
|
||||
while (true) {
|
||||
val client = try { socket.accept() } catch (e: IOException) { Log.e(TAG, "accept", e); break }
|
||||
Thread({ serve(app, client) }, "root-${seq.get() + 1}").apply { isDaemon = true; start() }
|
||||
}
|
||||
}, "root-server").apply { isDaemon = true; start() }
|
||||
}
|
||||
|
||||
private fun serve(context: Context, client: LocalSocket) {
|
||||
val id = seq.incrementAndGet()
|
||||
val received = ArrayList<FileDescriptor>()
|
||||
client.use {
|
||||
val out = DataOutputStream(client.outputStream)
|
||||
try {
|
||||
if (client.peerCredentials.uid != Process.myUid()) {
|
||||
Log.w(TAG, "refused root for uid ${client.peerCredentials.uid}")
|
||||
return
|
||||
}
|
||||
val input = DataInputStream(client.inputStream)
|
||||
val kind = input.readUnsignedByte()
|
||||
client.ancillaryFileDescriptors?.let { received.addAll(it) }
|
||||
val body = ByteArray(input.readInt()).also { input.readFully(it) }
|
||||
client.ancillaryFileDescriptors?.let { received.addAll(it) }
|
||||
if (kind != 'R'.code) return
|
||||
run(context, JSONObject(String(body, Charsets.UTF_8)), received, client, input, out, id)
|
||||
} catch (e: Exception) {
|
||||
Log.e(TAG, "root $id", e)
|
||||
runCatching {
|
||||
frame(out, 'E', (e.message ?: e.toString()).toByteArray())
|
||||
frame(out, 'X', "1".toByteArray())
|
||||
}
|
||||
} finally {
|
||||
received.forEach { fd -> runCatching { android.system.Os.close(fd) } }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class Stdio(val redirect: ProcessBuilder.Redirect?, val fd: FileDescriptor?, val dup: ParcelFileDescriptor?)
|
||||
|
||||
private fun stdio(fd: FileDescriptor?, write: Boolean): Stdio {
|
||||
if (fd == null) return Stdio(null, null, null)
|
||||
val dup = try { ParcelFileDescriptor.dup(fd) } catch (e: IOException) { return Stdio(null, fd, null) }
|
||||
val path = File("/proc/self/fd/${dup.fd}")
|
||||
val opens = try {
|
||||
if (write) FileOutputStream(path, true).close() else FileInputStream(path).close()
|
||||
true
|
||||
} catch (e: IOException) { false }
|
||||
if (!opens) return Stdio(null, fd, dup)
|
||||
val redirect = if (write) ProcessBuilder.Redirect.appendTo(path) else ProcessBuilder.Redirect.from(path)
|
||||
return Stdio(redirect, fd, dup)
|
||||
}
|
||||
|
||||
private fun pump(from: InputStream, to: OutputStream, name: String) =
|
||||
Thread({
|
||||
val buffer = ByteArray(16384)
|
||||
try {
|
||||
while (true) {
|
||||
val n = from.read(buffer)
|
||||
if (n < 0) break
|
||||
to.write(buffer, 0, n)
|
||||
to.flush()
|
||||
}
|
||||
} catch (e: IOException) {
|
||||
} finally {
|
||||
runCatching { to.close() }
|
||||
}
|
||||
}, name).apply { isDaemon = true; start() }
|
||||
|
||||
private fun run(context: Context, request: JSONObject, fds: List<FileDescriptor>, client: LocalSocket,
|
||||
input: DataInputStream, out: DataOutputStream, id: Int) {
|
||||
val root = LinuxRuntime.rootDir(context)
|
||||
val argv = request.getJSONArray("argv").let { a -> (0 until a.length()).map { a.getString(it) } }
|
||||
if (argv.isEmpty()) throw IOException("no command")
|
||||
val cwd = request.optString("cwd", "/root").ifEmpty { "/root" }
|
||||
val cmd = LinuxRuntime.prootPrefix(context, root, cwd, true)
|
||||
cmd.add(1, "--link2symlink")
|
||||
LinuxRuntime.lastBinds(context).filterNot { it.startsWith("/proc/self/fd/") }.forEach { cmd.add("-b"); cmd.add(it) }
|
||||
cmd.add("/usr/bin/env")
|
||||
cmd.add("-i")
|
||||
request.optJSONObject("env")?.let { e -> e.keys().forEach { k -> cmd.add("$k=${e.getString(k)}") } }
|
||||
cmd.addAll(argv)
|
||||
val builder = ProcessBuilder(cmd).directory(root)
|
||||
builder.environment().apply {
|
||||
clear()
|
||||
put("PROOT_LOADER", LinuxRuntime.prootLoader(context).path)
|
||||
put("PROOT_TMP_DIR", LinuxRuntime.prootTempDir(context).path)
|
||||
if (SessionPrefs.prootNoSeccomp(context)) put("PROOT_NO_SECCOMP", "1")
|
||||
LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) }
|
||||
}
|
||||
val streams = listOf(stdio(fds.getOrNull(0), false), stdio(fds.getOrNull(1), true), stdio(fds.getOrNull(2), true))
|
||||
try {
|
||||
builder.redirectInput(streams[0].redirect ?: ProcessBuilder.Redirect.PIPE)
|
||||
builder.redirectOutput(streams[1].redirect ?: ProcessBuilder.Redirect.PIPE)
|
||||
builder.redirectError(streams[2].redirect ?: ProcessBuilder.Redirect.PIPE)
|
||||
val process = builder.start()
|
||||
val pid = HostProcess.pidOf(process)
|
||||
OrphanReaper.keep(pid)
|
||||
Log.i(TAG, "root $id pid $pid: ${argv.joinToString(" ")}")
|
||||
synchronized(out) { frame(out, 'P', pid.toString().toByteArray()) }
|
||||
val pumps = ArrayList<Thread>()
|
||||
if (streams[0].redirect == null) {
|
||||
val fd = streams[0].fd
|
||||
if (fd != null) pumps.add(pump(FileInputStream(fd), process.outputStream, "root-$id-in").also { it.isDaemon = true })
|
||||
else runCatching { process.outputStream.close() }
|
||||
}
|
||||
if (streams[1].redirect == null) pumps.add(pump(process.inputStream,
|
||||
streams[1].fd?.let { FileOutputStream(it) } ?: OutputStream.nullOutputStream(), "root-$id-out"))
|
||||
if (streams[2].redirect == null) pumps.add(pump(process.errorStream,
|
||||
streams[2].fd?.let { FileOutputStream(it) } ?: OutputStream.nullOutputStream(), "root-$id-err"))
|
||||
Thread({
|
||||
try {
|
||||
while (true) {
|
||||
val kind = input.readUnsignedByte()
|
||||
val body = ByteArray(input.readInt()).also { input.readFully(it) }
|
||||
if (kind == 'S'.code) String(body).trim().toIntOrNull()?.let { signal(pid, it) }
|
||||
}
|
||||
} catch (e: IOException) {
|
||||
}
|
||||
if (process.isAlive) {
|
||||
Log.i(TAG, "root $id: its caller is gone; stopping it")
|
||||
signal(pid, android.system.OsConstants.SIGHUP)
|
||||
android.os.Process.sendSignal(pid, android.system.OsConstants.SIGQUIT)
|
||||
}
|
||||
}, "root-$id-watch").apply { isDaemon = true; start() }
|
||||
val status = process.waitFor()
|
||||
pumps.filter { it.name.endsWith("-out") || it.name.endsWith("-err") }.forEach { it.join(2000) }
|
||||
OrphanReaper.release(pid)
|
||||
Log.i(TAG, "root $id exited $status")
|
||||
runCatching { synchronized(out) { frame(out, 'X', status.toString().toByteArray()) } }
|
||||
} finally {
|
||||
streams.forEach { s -> runCatching { s.dup?.close() } }
|
||||
}
|
||||
}
|
||||
|
||||
private fun signal(top: Int, signal: Int) {
|
||||
val parents = HashMap<Int, Int>()
|
||||
File("/proc").listFiles()?.forEach { dir ->
|
||||
val pid = dir.name.toIntOrNull() ?: return@forEach
|
||||
val stat = try { File(dir, "stat").readText() } catch (e: IOException) { return@forEach }
|
||||
val fields = stat.substringAfterLast(')').trim().split(' ')
|
||||
fields.getOrNull(1)?.toIntOrNull()?.let { parents[pid] = it }
|
||||
}
|
||||
val tree = HashSet<Int>()
|
||||
var grew = true
|
||||
while (grew) {
|
||||
grew = false
|
||||
for ((pid, parent) in parents) {
|
||||
if (pid !in tree && (parent == top || parent in tree)) { tree.add(pid); grew = true }
|
||||
}
|
||||
}
|
||||
tree.forEach { runCatching { android.os.Process.sendSignal(it, signal) } }
|
||||
}
|
||||
|
||||
private fun frame(out: DataOutputStream, kind: Char, payload: ByteArray) {
|
||||
out.writeByte(kind.code)
|
||||
out.writeInt(payload.size)
|
||||
out.write(payload)
|
||||
out.flush()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import android.content.Context
|
||||
import com.droiddeck.launcher.BuildConfig
|
||||
|
||||
object RuntimeAutoUpdate {
|
||||
private const val PREFS = "runtime-auto-update"
|
||||
const val MAX_ATTEMPTS = 3
|
||||
const val RETRY_MS = 10 * 60_000L
|
||||
|
||||
fun due(installed: String?, release: String?, attempts: Int, lastAt: Long = 0L, now: Long = lastAt + RETRY_MS): Boolean =
|
||||
installed != null && !release.isNullOrEmpty() && release != installed && attempts < MAX_ATTEMPTS &&
|
||||
(attempts == 0 || now - lastAt !in 0 until RETRY_MS)
|
||||
|
||||
fun key(appVersion: Int, release: String) = "$appVersion:$release"
|
||||
|
||||
fun claim(context: Context, installed: String?, release: String?, now: Long = System.currentTimeMillis()): Boolean {
|
||||
if (release.isNullOrEmpty()) return false
|
||||
val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
|
||||
val key = key(BuildConfig.VERSION_CODE, release)
|
||||
synchronized(this) {
|
||||
val attempts = prefs.getInt(key, 0)
|
||||
if (!due(installed, release, attempts, prefs.getLong("$key@at", 0L), now)) return false
|
||||
val edit = prefs.edit()
|
||||
prefs.all.keys.filterNot { it.startsWith("${BuildConfig.VERSION_CODE}:") }.forEach { edit.remove(it) }
|
||||
edit.putInt(key, attempts + 1).putLong("$key@at", now).apply()
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -80,7 +80,7 @@ public final class RuntimeFileTree {
|
||||
* be carried.
|
||||
*/
|
||||
static java.util.List<String> userPaths(File tree) throws IOException {
|
||||
java.util.List<String> paths = new java.util.ArrayList<>(java.util.Arrays.asList("root", "opt/appimages/user", "opt/droiddeck-apps"));
|
||||
java.util.List<String> paths = new java.util.ArrayList<>(java.util.Arrays.asList("root", "opt/appimages/user", "opt/droiddeck-apps", "opt/droiddeck/wincomponents"));
|
||||
for (String n : children(new File(tree, "usr/local/share/applications"))) {
|
||||
if (n.endsWith(".desktop") && (n.startsWith("droiddeck-app-") || n.startsWith("droiddeck-appimage-")))
|
||||
paths.add("usr/local/share/applications/" + n);
|
||||
@@ -109,10 +109,39 @@ public final class RuntimeFileTree {
|
||||
|
||||
static java.util.List<String> existingUserPaths(File from, File to) throws IOException {
|
||||
java.util.List<String> paths = new java.util.ArrayList<>();
|
||||
for (String rel : userPaths(from, to)) if (exists(safePath(from, rel).toPath())) paths.add(rel);
|
||||
for (String rel : userPaths(from, to)) {
|
||||
if (!exists(safePath(from, rel).toPath())) continue;
|
||||
if (rel.startsWith("usr/share/applications/") && exists(safePath(to, rel).toPath())) continue;
|
||||
paths.add(rel);
|
||||
}
|
||||
return paths;
|
||||
}
|
||||
|
||||
private static final String[] STALE_HOME_STATE = {
|
||||
".local/share/droiddeck/pacman", ".cache/droiddeck/pacman-restore.log",
|
||||
".cache/appstream", ".cache/discover", ".cache/fontconfig", ".cache/kwin", ".cache/ksplash",
|
||||
".cache/ksvg-elements", ".cache/plasmashell", ".cache/kwinsession.kcache", ".cache/icon-cache.kcache",
|
||||
};
|
||||
private static final String[] STALE_HOME_CACHE_PREFIXES = {
|
||||
"mesa_shader_cache", "ksycoca", "plasma_theme_", "qtshadercache", "event-sound-cache.tdb.",
|
||||
};
|
||||
|
||||
static void dropStaleState(File runtimeRoot) throws IOException {
|
||||
File home = new File(runtimeRoot, "root");
|
||||
java.util.List<String> stale = new java.util.ArrayList<>(java.util.Arrays.asList(STALE_HOME_STATE));
|
||||
for (String n : children(new File(home, ".cache"))) {
|
||||
for (String prefix : STALE_HOME_CACHE_PREFIXES) {
|
||||
if (n.startsWith(prefix)) { stale.add(".cache/" + n); break; }
|
||||
}
|
||||
}
|
||||
IOException failed = null;
|
||||
for (String rel : stale) {
|
||||
try { delete(safePath(home, rel), null); }
|
||||
catch (IOException e) { if (failed == null) failed = e; else failed.addSuppressed(e); }
|
||||
}
|
||||
if (failed != null) throw failed;
|
||||
}
|
||||
|
||||
private static java.util.List<String> children(File dir) throws IOException {
|
||||
java.util.List<String> names = new java.util.ArrayList<>();
|
||||
try (DirectoryStream<Path> entries = Files.newDirectoryStream(dir.toPath())) {
|
||||
|
||||
@@ -11,14 +11,15 @@ object RuntimeHealth {
|
||||
fun brokenLibraryLinks(context: Context): List<String> = brokenLibraryLinks(LinuxRuntime.rootDir(context))
|
||||
|
||||
/** A complete runtime has no library link in usr/lib whose target is missing. */
|
||||
fun brokenLibraryLinks(root: File): List<String> {
|
||||
val lib = File(root, "usr/lib")
|
||||
val names = lib.list() ?: return emptyList()
|
||||
return names.sorted().filter { name ->
|
||||
val path = File(lib, name).toPath()
|
||||
Files.isSymbolicLink(path) && !resolves(root, path)
|
||||
fun brokenLibraryLinks(root: File): List<String> =
|
||||
listOf("usr/lib", "usr/lib/aarch64-linux-gnu").flatMap { dir ->
|
||||
val lib = File(root, dir)
|
||||
val names = lib.list() ?: return@flatMap emptyList()
|
||||
names.sorted().filter { name ->
|
||||
val path = File(lib, name).toPath()
|
||||
Files.isSymbolicLink(path) && !resolves(root, path)
|
||||
}.map { if (dir == "usr/lib") it else "aarch64-linux-gnu/$it" }
|
||||
}
|
||||
}
|
||||
|
||||
private fun resolves(root: File, link: Path): Boolean = try {
|
||||
var path = link
|
||||
|
||||
Reference in new issue
Block a user