mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 21:06:09 +00:00
chore: merge main into feat/lse-emu
This commit is contained in:
commit
73104aff03
667 files changed
+75245
-4143
No files matched your search
@@ -7,8 +7,11 @@ import com.droiddeck.launcher.session.EnhancedSessionLogShare
|
||||
import com.droiddeck.launcher.session.GpuClockPin
|
||||
|
||||
class App : Application() {
|
||||
override fun attachBaseContext(base: android.content.Context) =
|
||||
override fun attachBaseContext(base: android.content.Context) {
|
||||
super.attachBaseContext(com.droiddeck.launcher.core.AppLanguage.wrap(base))
|
||||
val process = if (android.os.Build.VERSION.SDK_INT >= 28) Application.getProcessName() else packageName
|
||||
com.droiddeck.launcher.lab.LabOverlay.load(this, process == packageName)
|
||||
}
|
||||
|
||||
override fun onConfigurationChanged(newConfig: android.content.res.Configuration) {
|
||||
super.onConfigurationChanged(newConfig)
|
||||
@@ -39,14 +42,21 @@ class App : Application() {
|
||||
if (process == "$packageName:vr_recovery" || process == "$packageName:rgb_diagnostic" ||
|
||||
process == "$packageName:shortcuts_sync" || process == "$packageName:bottom_desktop") return
|
||||
CrashHandler.install(this)
|
||||
com.droiddeck.launcher.core.SteamIntegration.syncShortcutsListing(this)
|
||||
com.droiddeck.launcher.agent.AgentHost.refresh(this)
|
||||
com.droiddeck.launcher.agent.AgentTab.load(this)
|
||||
com.droiddeck.launcher.ui.NavTabs.load(this)
|
||||
com.droiddeck.launcher.ui.AgentPet.install(this)
|
||||
if (com.droiddeck.launcher.agent.AgentTab.visible) com.droiddeck.launcher.lab.LabNotice.openOnInstall = "agent"
|
||||
com.droiddeck.launcher.lab.LabNotice.started(this)
|
||||
com.droiddeck.launcher.session.QuestExperimental.initialize(this)
|
||||
com.droiddeck.launcher.session.SessionPrefs.applyNtsyncDefault(this)
|
||||
com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this)
|
||||
com.droiddeck.launcher.update.AppUpdates.init(this)
|
||||
com.droiddeck.launcher.update.UpdateWatch.sync(this, com.droiddeck.launcher.update.AppUpdates.follow(this, null))
|
||||
com.droiddeck.launcher.core.DownloadSource.init(this)
|
||||
prefetchAddonPacks()
|
||||
GpuClockPin.clearLeftover(this)
|
||||
com.droiddeck.launcher.input.UsbMouse.returnLeftover(this)
|
||||
com.droiddeck.launcher.glasses.Glasses.init(this)
|
||||
com.droiddeck.launcher.glasses.GlassesMenuMirror.initialize(this)
|
||||
BwrapSpawner.start(this)
|
||||
@@ -64,6 +74,7 @@ class App : Application() {
|
||||
com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.ubisoft.UbisoftBackend)
|
||||
com.droiddeck.launcher.stores.ea.EaBackend.app = this
|
||||
com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.ea.EaBackend)
|
||||
com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.rockstar.RockstarBackend)
|
||||
}
|
||||
|
||||
private fun prefetchAddonPacks() {
|
||||
@@ -73,12 +84,15 @@ class App : Application() {
|
||||
if (com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(app).isDirectory) {
|
||||
com.droiddeck.launcher.core.AddonPack.PROOT.ensure(app)
|
||||
com.droiddeck.launcher.core.AddonPack.DIRECTAUDIO.ensure(app)
|
||||
com.droiddeck.launcher.session.SessionFiles.ensureDirtStandIn(app)
|
||||
}
|
||||
if (com.droiddeck.launcher.stores.gog.GogComet.enabled(app)) com.droiddeck.launcher.core.AddonPack.COMET.ensure(app)
|
||||
if (com.droiddeck.launcher.stores.StoreAccounts.signedInAs(app, com.droiddeck.launcher.stores.Store.XBOX) != null)
|
||||
com.droiddeck.launcher.core.AddonPack.XBOX.ensure(app)
|
||||
if (com.droiddeck.launcher.stores.StoreAccounts.signedInAs(app, com.droiddeck.launcher.stores.Store.UBISOFT) != null)
|
||||
com.droiddeck.launcher.session.SessionFiles.ensureUbisoftService(app)
|
||||
if (com.droiddeck.launcher.stores.StoreAccounts.signedInAs(app, com.droiddeck.launcher.stores.Store.ROCKSTAR) != null)
|
||||
com.droiddeck.launcher.session.SessionFiles.ensureRockstarService(app)
|
||||
com.droiddeck.launcher.handtracking.HandTracking.load(app)
|
||||
}.onFailure { android.util.Log.w("App", "add-on pack prefetch failed", it) }
|
||||
}, "addon-packs").start()
|
||||
|
||||
@@ -0,0 +1,167 @@
|
||||
package com.droiddeck.launcher
|
||||
|
||||
import android.app.ActivityOptions
|
||||
import android.app.PictureInPictureParams
|
||||
import android.content.ClipData
|
||||
import android.content.ClipboardManager
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.res.Configuration
|
||||
import android.net.Uri
|
||||
import android.os.Bundle
|
||||
import android.util.Rational
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.BackHandler
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.compose.foundation.background
|
||||
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.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.widthIn
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.res.stringResource
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import com.droiddeck.launcher.core.AppLanguage
|
||||
import com.droiddeck.launcher.ui.DroidDeckTheme
|
||||
import com.droiddeck.launcher.ui.FitText
|
||||
import com.droiddeck.launcher.ui.LocalPalette
|
||||
import com.droiddeck.launcher.ui.PrimaryButton
|
||||
import com.droiddeck.launcher.ui.SecondaryButton
|
||||
import java.lang.ref.WeakReference
|
||||
|
||||
/** Floats a sign-in code over the browser page that asks for it. */
|
||||
class DeviceCodeActivity : ComponentActivity() {
|
||||
private var code by mutableStateOf("")
|
||||
private var url = ""
|
||||
private var display: Int? = null
|
||||
private var inPip by mutableStateOf(false)
|
||||
private var openPending = false
|
||||
|
||||
override fun attachBaseContext(newBase: Context) = super.attachBaseContext(AppLanguage.wrap(newBase))
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
current = WeakReference(this)
|
||||
read(intent)
|
||||
openPending = savedInstanceState == null
|
||||
setContent { DroidDeckTheme { Float() } }
|
||||
}
|
||||
|
||||
override fun onNewIntent(intent: Intent) {
|
||||
super.onNewIntent(intent)
|
||||
setIntent(intent)
|
||||
read(intent)
|
||||
openPending = true
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
if (current?.get() === this) current = null
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
override fun onResume() {
|
||||
super.onResume()
|
||||
if (!openPending) return
|
||||
if (isInPictureInPictureMode) {
|
||||
openPage()
|
||||
return
|
||||
}
|
||||
enterPip()
|
||||
if (!inPip) {
|
||||
openPage()
|
||||
finish()
|
||||
}
|
||||
}
|
||||
|
||||
override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration) {
|
||||
super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
|
||||
inPip = isInPictureInPictureMode
|
||||
if (isInPictureInPictureMode && openPending) openPage()
|
||||
}
|
||||
|
||||
private fun read(intent: Intent) {
|
||||
code = intent.getStringExtra(EXTRA_CODE).orEmpty()
|
||||
url = intent.getStringExtra(EXTRA_URL).orEmpty()
|
||||
display = intent.getIntExtra(EXTRA_DISPLAY, -1).takeIf { it > 0 }
|
||||
copy()
|
||||
}
|
||||
|
||||
private fun copy() {
|
||||
runCatching { getSystemService(ClipboardManager::class.java)?.setPrimaryClip(ClipData.newPlainText("GitHub", code)) }
|
||||
}
|
||||
|
||||
private fun enterPip() {
|
||||
inPip = runCatching {
|
||||
enterPictureInPictureMode(PictureInPictureParams.Builder().setAspectRatio(Rational(16, 9)).build())
|
||||
}.getOrDefault(false)
|
||||
}
|
||||
|
||||
private fun openPage() {
|
||||
openPending = false
|
||||
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url)).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
val at = display
|
||||
val opened = runCatching {
|
||||
if (at == null) startActivity(intent)
|
||||
else startActivity(intent, ActivityOptions.makeBasic().setLaunchDisplayId(at).toBundle())
|
||||
}.recoverCatching { startActivity(intent) }.isSuccess
|
||||
com.droiddeck.launcher.agent.AgentHost.deviceCodeOpened(applicationContext, opened)
|
||||
}
|
||||
|
||||
@androidx.compose.runtime.Composable
|
||||
private fun Float() {
|
||||
val colors = MaterialTheme.colorScheme
|
||||
val accent = LocalPalette.current.signal
|
||||
BackHandler(enabled = !inPip) { enterPip() }
|
||||
Box(Modifier.fillMaxSize().background(colors.background), contentAlignment = Alignment.Center) {
|
||||
Column(
|
||||
Modifier.widthIn(max = 520.dp).fillMaxWidth().padding(if (inPip) 8.dp else 24.dp),
|
||||
horizontalAlignment = Alignment.CenterHorizontally,
|
||||
verticalArrangement = Arrangement.spacedBy(if (inPip) 2.dp else 16.dp),
|
||||
) {
|
||||
Text(stringResource(R.string.agent_step_github), style = MaterialTheme.typography.labelLarge, color = colors.onSurfaceVariant)
|
||||
FitText(code, maxSize = if (inPip) 40.sp else 56.sp, fontWeight = FontWeight.Bold, color = accent,
|
||||
modifier = Modifier.fillMaxWidth())
|
||||
Text(Uri.parse(url).let { it.host + it.path }, style = MaterialTheme.typography.labelMedium, color = colors.onSurfaceVariant, maxLines = 1)
|
||||
if (!inPip) Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
|
||||
PrimaryButton(stringResource(R.string.fm_copy), onClick = ::copy)
|
||||
SecondaryButton(stringResource(R.string.common_close), onClick = ::finish)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val EXTRA_CODE = "code"
|
||||
private const val EXTRA_URL = "url"
|
||||
private const val EXTRA_DISPLAY = "display"
|
||||
private var current: WeakReference<DeviceCodeActivity>? = null
|
||||
|
||||
/** False when this device cannot float a window, so the caller opens the page itself. */
|
||||
fun show(context: Context, code: String, url: String, display: Int): Boolean {
|
||||
if (!PairingGuideActivity.canFloat(context)) return false
|
||||
val intent = Intent(context, DeviceCodeActivity::class.java)
|
||||
.putExtra(EXTRA_CODE, code).putExtra(EXTRA_URL, url).putExtra(EXTRA_DISPLAY, display)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
return runCatching {
|
||||
if (display > 0) context.startActivity(intent, ActivityOptions.makeBasic().setLaunchDisplayId(display).toBundle())
|
||||
else context.startActivity(intent)
|
||||
}.isSuccess
|
||||
}
|
||||
|
||||
fun close() {
|
||||
current?.get()?.finish()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -286,7 +286,13 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
|
||||
// Builds before 0.5.0-nad1 turned the bridge on under Auto without recording it, and
|
||||
// left it on for good (it wins over the pair). Under Auto that switch is taken as Auto's.
|
||||
if (!SessionPrefs.maliFallbackKnown(activity))
|
||||
SessionPrefs.setMaliFallbackByAuto(activity, if (SessionPrefs.vkBridge(activity)) "bridge" else "")
|
||||
SessionPrefs.setMaliFallbackByAuto(
|
||||
activity,
|
||||
MaliAutoRoute.initialOwnership(
|
||||
SessionPrefs.vkBridge(activity), bridgeExplicit(),
|
||||
SessionPrefs.venus(activity), venusExplicit(),
|
||||
),
|
||||
)
|
||||
// A lone imported PanVK Android driver set by hand stalls the display the same way
|
||||
// ("black screen with the start-up logo"), so under Auto any imported display goes.
|
||||
val display = SessionPrefs.androidDriver(activity)
|
||||
@@ -356,8 +362,14 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
|
||||
val pair = pairs.firstOrNull { it.key == key }
|
||||
val row = pairRows.firstOrNull { it.key == key }
|
||||
when {
|
||||
row?.active == true -> autoStatus = problem?.let { activity.getString(R.string.drivers_up_to_date_check_failed, it) }
|
||||
?: activity.getString(R.string.upd_current_status)
|
||||
row?.active == true -> {
|
||||
if (MaliAutoRoute.shouldEnd(
|
||||
SessionPrefs.maliFallbackByAuto(activity), gpu.family.mali,
|
||||
pair?.key?.let { DriverPairs.isNonAdreno(it) } == true,
|
||||
)) endMaliFallback()
|
||||
autoStatus = problem?.let { activity.getString(R.string.drivers_up_to_date_check_failed, it) }
|
||||
?: activity.getString(R.string.upd_current_status)
|
||||
}
|
||||
gpu.family == GpuInfo.Family.POWERVR && (pair == null || !pair.complete) -> {
|
||||
// RADV is not published right now: the Xclipse falls back to the system route.
|
||||
SessionPrefs.ensurePowerVrAutoDrivers(activity)
|
||||
@@ -397,6 +409,12 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
|
||||
}, "gpu-driver-auto").start()
|
||||
}
|
||||
|
||||
private fun bridgeExplicit(): Boolean =
|
||||
MaliAutoRoute.userChoice(SessionPrefs.vkBridgeExplicit(activity), SessionPrefs.maliFallbackByAuto(activity), MaliAutoRoute.BRIDGE)
|
||||
|
||||
private fun venusExplicit(): Boolean =
|
||||
MaliAutoRoute.userChoice(SessionPrefs.venusExplicit(activity), SessionPrefs.maliFallbackByAuto(activity), MaliAutoRoute.VENUS)
|
||||
|
||||
/**
|
||||
* A Mali with no open driver pair to install ([missing] names the unpublished pair, or null when
|
||||
* no PanVK build covers this GPU) runs through the phone's own driver: Mali (Venus) where this
|
||||
@@ -410,12 +428,21 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
|
||||
val oldVulkan = com.droiddeck.launcher.session.VenusComponent.hostVulkanTooOld(activity)
|
||||
val venus = oldVulkan == null && com.droiddeck.launcher.session.VenusComponent.available(activity)
|
||||
if (oldVulkan != null) Log.i(TAG, "auto: Mali driver reports Vulkan $oldVulkan; Venus needs 1.2, the bridge stands in")
|
||||
val ownership = MaliAutoRoute.fallbackOwnership(
|
||||
venus,
|
||||
SessionPrefs.vkBridge(activity), bridgeExplicit(),
|
||||
SessionPrefs.venus(activity), venusExplicit(),
|
||||
)
|
||||
if (venus && !SessionPrefs.venus(activity)) {
|
||||
SessionPrefs.setVenus(activity, true)
|
||||
SessionPrefs.setMaliFallbackByAuto(activity, "venus")
|
||||
if (SessionPrefs.vkBridge(activity) && !bridgeExplicit())
|
||||
SessionPrefs.setVkBridge(activity, false)
|
||||
SessionPrefs.setMaliFallbackByAuto(activity, ownership)
|
||||
} else if (!venus && !SessionPrefs.vkBridge(activity)) {
|
||||
SessionPrefs.setVkBridge(activity, true)
|
||||
SessionPrefs.setMaliFallbackByAuto(activity, "bridge")
|
||||
SessionPrefs.setMaliFallbackByAuto(activity, ownership)
|
||||
} else if (ownership != MaliAutoRoute.NONE) {
|
||||
SessionPrefs.setMaliFallbackByAuto(activity, ownership)
|
||||
}
|
||||
val route = activity.getString(if (venus) R.string.drivers_route_venus else R.string.drivers_route_bridge)
|
||||
Log.i(TAG, "auto: Mali stand-in route $route (missing pair: ${missing ?: "none covers ${gpu.name}"})")
|
||||
@@ -503,7 +530,9 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
|
||||
// A route Auto switched on in place of a missing pair goes off now that one is
|
||||
// here. A Mali bridge or Venus switch the user set stays: it wins for the session
|
||||
// (DeviceSupport.vkBridge, VenusComponent.wanted) and the pair waits.
|
||||
if (gpu.family.mali && DriverPairs.isNonAdreno(pair.key)) endMaliFallback()
|
||||
if (MaliAutoRoute.shouldEnd(
|
||||
SessionPrefs.maliFallbackByAuto(activity), gpu.family.mali, DriverPairs.isNonAdreno(pair.key),
|
||||
)) endMaliFallback()
|
||||
val restart = displayChanged && CompositorHost.isStarted
|
||||
if (auto) {
|
||||
val trial = AutoDriverTrial.current(activity)
|
||||
@@ -744,4 +773,3 @@ internal fun Context.displayNameOf(uri: Uri): String? = if (uri.scheme == "file"
|
||||
} catch (e: Exception) {
|
||||
null
|
||||
}
|
||||
|
||||
@@ -84,7 +84,7 @@ import com.droiddeck.launcher.session.SteamLibraries
|
||||
import com.droiddeck.launcher.input.SecondScreenDisplay
|
||||
import com.droiddeck.launcher.input.SecondScreenDisplays
|
||||
|
||||
class FrontEndActivity : ComponentActivity() {
|
||||
class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPetHost {
|
||||
override fun attachBaseContext(newBase: android.content.Context) {
|
||||
super.attachBaseContext(newBase)
|
||||
com.droiddeck.launcher.core.AppLanguage.applyTo(this, newBase)
|
||||
@@ -179,12 +179,15 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private var syncFallback by mutableStateOf(true)
|
||||
private var fsyncFirst by mutableStateOf(false)
|
||||
private var gamescopeRealtime by mutableStateOf(false)
|
||||
private var paceCores by mutableStateOf(true)
|
||||
private var ramCapMb by mutableStateOf(0)
|
||||
private var zramClient by mutableStateOf(true)
|
||||
private var zramIdle by mutableStateOf(true)
|
||||
private var vramCapMb by mutableStateOf(0)
|
||||
private var gpuClockPin by mutableStateOf(false)
|
||||
private var prootNoSeccomp by mutableStateOf(false)
|
||||
private var prootFastPath by mutableStateOf(true)
|
||||
private var nativeUserland by mutableStateOf(false)
|
||||
private var cursorComposite by mutableStateOf(false)
|
||||
private var guestHostname by mutableStateOf(SessionPrefs.DEFAULT_GUEST_HOSTNAME)
|
||||
private var phantomWarning by mutableStateOf<String?>(null)
|
||||
@@ -195,6 +198,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private var stretch16x9 by mutableStateOf(false)
|
||||
private var orientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE)
|
||||
private var launcherOrientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER)
|
||||
private var homePage by mutableStateOf(com.droiddeck.launcher.core.AppUiPrefs.HOME_PAGE_STEAM)
|
||||
private var launcherFullscreen by mutableStateOf(true)
|
||||
private var downloadSource by mutableStateOf(DownloadSource.MODE_AUTO)
|
||||
private var downloadMirror by mutableStateOf("")
|
||||
@@ -204,6 +208,10 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private var lowStorageWarning by mutableStateOf(true)
|
||||
private var launcherIcon by mutableStateOf(LauncherIcon.DARK)
|
||||
private var gameStoresEnabled by mutableStateOf(true)
|
||||
private var soundtracksEnabled by mutableStateOf(true)
|
||||
private var soundtracksIngame by mutableStateOf(false)
|
||||
private var soundtracks by mutableStateOf<List<Library.SteamGame>>(emptyList())
|
||||
private var soundtracksLoaded by mutableStateOf(false)
|
||||
private var gameStoresSpeedTier by mutableStateOf("fast")
|
||||
private var navRequest by mutableStateOf<String?>(null)
|
||||
private val gameLaunchRequest = java.util.concurrent.atomic.AtomicLong()
|
||||
@@ -225,6 +233,11 @@ class FrontEndActivity : ComponentActivity() {
|
||||
refreshWifiDiscovery()
|
||||
}
|
||||
}
|
||||
private val dateReceiver = object : android.content.BroadcastReceiver() {
|
||||
override fun onReceive(context: android.content.Context?, intent: Intent?) {
|
||||
refreshAndroidApps()
|
||||
}
|
||||
}
|
||||
private val mediaRefresh = Runnable {
|
||||
refresh()
|
||||
refreshAddedGames()
|
||||
@@ -354,15 +367,78 @@ class FrontEndActivity : ComponentActivity() {
|
||||
SteamIntegration.Feature.BRIGHTNESS -> integrationSettings(SteamIntegration.brightnessSettings(this))
|
||||
SteamIntegration.Feature.HOME -> if (HomeApp.isDefault(this)) HomeApp.openSystemHomeSettings(this) else offerHomeScreen()
|
||||
SteamIntegration.Feature.SHORTCUTS -> {
|
||||
if (!integrationState.shortcuts) shortcutsTried = true
|
||||
SteamIntegration.setShortcutsListed(this, true)
|
||||
integrationSettings(SteamIntegration.shortcutSettings(this), android.provider.Settings.ACTION_ACCESSIBILITY_SETTINGS)
|
||||
if (integrationState.shortcuts) openShortcutSettings() else installShortcuts()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun openAppInfo() =
|
||||
integrationSettings(Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:$packageName")))
|
||||
private fun openShortcutSettings() =
|
||||
integrationSettings(SteamIntegration.shortcutSettings(this), android.provider.Settings.ACTION_ACCESSIBILITY_SETTINGS)
|
||||
|
||||
private fun installShortcuts() {
|
||||
if (ShortcutsInstall.running) return
|
||||
ShortcutsInstall.running = true
|
||||
Thread({
|
||||
val result = runCatching {
|
||||
val apk = SteamIntegration.bundledShortcuts(this)
|
||||
when {
|
||||
SteamIntegration.shortcutsInstalled(this, apk) -> {
|
||||
ShortcutsInstall.running = false
|
||||
ui.post { shortcutsReady() }
|
||||
}
|
||||
!com.droiddeck.launcher.update.SelfInstaller.canInstall(this) -> {
|
||||
ShortcutsInstall.running = false
|
||||
ui.post { integrationSettings(com.droiddeck.launcher.update.SelfInstaller.permissionIntent(this)) }
|
||||
}
|
||||
else -> com.droiddeck.launcher.update.SelfInstaller.install(this, apk, com.droiddeck.shortcuts.Relay.PACKAGE,
|
||||
SteamIntegration.SHORTCUTS_STATUS) { id -> ShortcutsInstall.session = id }
|
||||
}
|
||||
}
|
||||
result.onFailure { e ->
|
||||
ShortcutsInstall.running = false
|
||||
ui.post { shortcutsFailed(e.message) }
|
||||
}
|
||||
}, "shortcuts-install").start()
|
||||
}
|
||||
|
||||
private fun shortcutsReady() {
|
||||
shortcutsTried = true
|
||||
Thread({
|
||||
val deadline = android.os.SystemClock.uptimeMillis() + 3000
|
||||
while (!SteamIntegration.shortcutsListed(this) && android.os.SystemClock.uptimeMillis() < deadline) Thread.sleep(100)
|
||||
ui.post { openShortcutSettings() }
|
||||
}, "shortcuts-listed").start()
|
||||
}
|
||||
|
||||
private fun shortcutsFailed(message: String?) {
|
||||
android.widget.Toast.makeText(this, message?.let { getString(R.string.integration_shortcuts_install_failed_with, it) }
|
||||
?: getString(R.string.integration_shortcuts_install_failed), android.widget.Toast.LENGTH_LONG).show()
|
||||
}
|
||||
|
||||
private val shortcutsInstallStatus = object : android.content.BroadcastReceiver() {
|
||||
override fun onReceive(context: android.content.Context, intent: Intent) {
|
||||
val session = intent.getIntExtra(android.content.pm.PackageInstaller.EXTRA_SESSION_ID, -1)
|
||||
if (session < 0 || session != ShortcutsInstall.session) return
|
||||
val status = intent.getIntExtra(android.content.pm.PackageInstaller.EXTRA_STATUS,
|
||||
android.content.pm.PackageInstaller.STATUS_FAILURE)
|
||||
if (status != android.content.pm.PackageInstaller.STATUS_PENDING_USER_ACTION) {
|
||||
ShortcutsInstall.session = -1
|
||||
ShortcutsInstall.running = false
|
||||
}
|
||||
when (status) {
|
||||
android.content.pm.PackageInstaller.STATUS_PENDING_USER_ACTION -> {
|
||||
val confirm = if (android.os.Build.VERSION.SDK_INT >= 33) intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
|
||||
else @Suppress("DEPRECATION") intent.getParcelableExtra(Intent.EXTRA_INTENT)
|
||||
val safe = confirm?.let { com.droiddeck.launcher.update.SelfInstaller.safeConfirmIntent(this@FrontEndActivity, it) }
|
||||
if (safe == null || runCatching { startActivity(safe) }.isFailure) shortcutsFailed(null)
|
||||
}
|
||||
android.content.pm.PackageInstaller.STATUS_SUCCESS -> shortcutsReady()
|
||||
else -> shortcutsFailed(intent.getStringExtra(android.content.pm.PackageInstaller.EXTRA_STATUS_MESSAGE))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun openAppInfo() = integrationSettings(SteamIntegration.shortcutsAppInfo())
|
||||
|
||||
private fun openWifiDiscoverySettings() {
|
||||
if (!WifiDiscovery.permissionGranted(this)) {
|
||||
@@ -523,6 +599,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private var upscaleSharpness by mutableStateOf(75)
|
||||
private var hdrReason by mutableStateOf<String?>(null)
|
||||
private var touchMode by mutableStateOf(SessionPrefs.TOUCH_AUTO)
|
||||
private var pen by mutableStateOf<SessionPrefs.Pen?>(null)
|
||||
private var suspendPolicy by mutableStateOf(SessionPrefs.SUSPEND_MANUAL)
|
||||
private var steamDownloadsInBackground by mutableStateOf(false)
|
||||
private var oscMode by mutableStateOf(SessionPrefs.OSC_AUTO)
|
||||
@@ -592,6 +669,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private var vacDiagnostics by mutableStateOf(false)
|
||||
private var agentCommands by mutableStateOf(false)
|
||||
private var graphicsLogs by mutableStateOf(false)
|
||||
private var buildWatermark by mutableStateOf(true)
|
||||
private var steamGpuDrawing by mutableStateOf(false)
|
||||
private var bridgeFellBack by mutableStateOf(false)
|
||||
private var bridgeFellBackMemory by mutableStateOf(false)
|
||||
@@ -777,6 +855,11 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private var shortcutPicker by mutableStateOf(false)
|
||||
private var shortcutLibraryScanning by mutableStateOf(false)
|
||||
@Volatile private var libraryScanGeneration = 0
|
||||
private class SoundtrackRemoval(val op: Int, var scan: Int, var settled: Boolean)
|
||||
private val soundtrackRemovals = HashMap<String, SoundtrackRemoval>()
|
||||
private var soundtrackOp = 0
|
||||
private var soundtrackAddScan = -1
|
||||
private val soundtrackWork = java.util.concurrent.Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-work").apply { isDaemon = true } }
|
||||
@Volatile private var lastComponentRestore = 0L
|
||||
@Volatile private var componentRestoreRetry = false
|
||||
private val componentRestoreLock = Any()
|
||||
@@ -827,6 +910,10 @@ class FrontEndActivity : ComponentActivity() {
|
||||
|
||||
private fun readGameIntent(request: Intent) {
|
||||
request.getStringExtra(com.droiddeck.launcher.stores.download.StoreDownloadService.EXTRA_NAV)?.let { navRequest = it; request.removeExtra(com.droiddeck.launcher.stores.download.StoreDownloadService.EXTRA_NAV) }
|
||||
if (navRequest == com.droiddeck.launcher.core.AppUiPrefs.HOME_PAGE_APPS) {
|
||||
homeAppSelected = HomeApp.isHomeScreenEnabled(this) && HomeApp.isDefault(this)
|
||||
if (!homeAppSelected) navRequest = null
|
||||
}
|
||||
shortcutPicker = request.action == Intent.ACTION_CREATE_SHORTCUT
|
||||
if (shortcutPicker) {
|
||||
steamGames = emptyList()
|
||||
@@ -835,6 +922,15 @@ class FrontEndActivity : ComponentActivity() {
|
||||
pendingGameLink = null
|
||||
gameLinkReading = false
|
||||
gameLinkTried = false
|
||||
soundtrackLaunch = false
|
||||
val soundtrackId = com.droiddeck.launcher.frontend.SoundtrackShortcuts.read(request)
|
||||
if (soundtrackId != null) {
|
||||
soundtrackLaunch = true
|
||||
navRequest = if (SessionPrefs.soundtracksEnabled(this)) "sound:$soundtrackId" else "app:$soundtrackId"
|
||||
request.data = null
|
||||
request.action = Intent.ACTION_MAIN
|
||||
return
|
||||
}
|
||||
if (GameLaunchIntent.accepts(request.action)) {
|
||||
gameLinkReading = true
|
||||
com.droiddeck.launcher.ui.DualScreenPanel.hide(taskId)
|
||||
@@ -858,12 +954,15 @@ class FrontEndActivity : ComponentActivity() {
|
||||
}
|
||||
}
|
||||
|
||||
private fun launchGame(game: Library.SteamGame, returnHome: Boolean = false): Boolean {
|
||||
private fun launchGame(game: Library.SteamGame, returnHome: Boolean = false, onHandled: () -> Unit = {}): Boolean {
|
||||
if (!SessionPrefs.soundtracksIngame(this)) com.droiddeck.launcher.playback.SoundtrackController.pause(this)
|
||||
if (pkgStage != null) {
|
||||
onHandled()
|
||||
android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show()
|
||||
return false
|
||||
}
|
||||
if (com.droiddeck.launcher.session.NoSteamLaunch.enabled(this, game)) return launchWithoutSteam(game, returnHome)
|
||||
if (com.droiddeck.launcher.session.NoSteamLaunch.enabled(this, game)) return launchWithoutSteam(game, returnHome, onHandled)
|
||||
onHandled()
|
||||
if (SessionState.running) {
|
||||
if (SessionState.mode != SessionService.MODE_STEAM || SessionState.stopRequested) {
|
||||
android.widget.Toast.makeText(this, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show()
|
||||
@@ -907,12 +1006,13 @@ class FrontEndActivity : ComponentActivity() {
|
||||
.apply { if (returnHome) putExtra(SessionActivity.EXTRA_LINK_TASK, task) }
|
||||
}
|
||||
|
||||
private fun launchWithoutSteam(game: Library.SteamGame, returnHome: Boolean): Boolean {
|
||||
private fun launchWithoutSteam(game: Library.SteamGame, returnHome: Boolean, onHandled: () -> Unit = {}): Boolean {
|
||||
val app = applicationContext
|
||||
Thread({
|
||||
val added = if (game.library == Library.ADDED) runCatching { com.droiddeck.launcher.session.NoSteamLaunch.addedGame(app, game) }.getOrNull() else null
|
||||
val added = if (com.droiddeck.launcher.session.NoSteamLaunch.needsAddedGame(game)) runCatching { com.droiddeck.launcher.session.NoSteamLaunch.addedGame(app, game) }.getOrNull() else null
|
||||
val command = com.droiddeck.launcher.session.NoSteamLaunch.command(game, added)
|
||||
ui.post {
|
||||
onHandled()
|
||||
if (isDestroyed) return@post
|
||||
if (command == null) {
|
||||
android.widget.Toast.makeText(this, R.string.game_link_failed, android.widget.Toast.LENGTH_LONG).show()
|
||||
@@ -1103,7 +1203,12 @@ class FrontEndActivity : ComponentActivity() {
|
||||
homeChoiceOpen = savedInstanceState?.getBoolean(STATE_HOME_CHOICE_OPEN) == true
|
||||
gameSpaceOffered = savedInstanceState?.getBoolean(STATE_GAME_SPACE_OFFERED) == true
|
||||
if (savedInstanceState == null) readIntegrationIntent(intent)
|
||||
val shortcutsFilter = android.content.IntentFilter(SteamIntegration.SHORTCUTS_STATUS)
|
||||
if (android.os.Build.VERSION.SDK_INT >= 33) registerReceiver(shortcutsInstallStatus, shortcutsFilter, RECEIVER_NOT_EXPORTED)
|
||||
else registerReceiver(shortcutsInstallStatus, shortcutsFilter)
|
||||
readGameIntent(intent)
|
||||
// A Lab build is usually the agent's work, so the app comes back where the agent is.
|
||||
if (savedInstanceState == null && navRequest == null && com.droiddeck.launcher.lab.LabOverlay.promoted && com.droiddeck.launcher.agent.AgentTab.visible) navRequest = "agent"
|
||||
gameSyncFolder = GameFileSync.folder(this)
|
||||
displayManager = getSystemService(DISPLAY_SERVICE) as DisplayManager
|
||||
refreshPhantomStatus()
|
||||
@@ -1118,6 +1223,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
orientation = SessionPrefs.orientation(this)
|
||||
launcherOrientation = com.droiddeck.launcher.core.AppUiPrefs.orientation(this)
|
||||
requestedOrientation = launcherOrientation
|
||||
homePage = com.droiddeck.launcher.core.AppUiPrefs.homePage(this)
|
||||
launcherFullscreen = SessionPrefs.launcherFullscreen(this)
|
||||
downloadSource = DownloadSource.mode(this)
|
||||
downloadMirror = DownloadSource.mirror(this)
|
||||
@@ -1129,6 +1235,8 @@ class FrontEndActivity : ComponentActivity() {
|
||||
LauncherIcon.repair(this, intent?.component)
|
||||
launcherIcon = LauncherIcon.current(this)
|
||||
gameStoresEnabled = SessionPrefs.gameStoresEnabled(this)
|
||||
soundtracksEnabled = SessionPrefs.soundtracksEnabled(this)
|
||||
soundtracksIngame = SessionPrefs.soundtracksIngame(this)
|
||||
gameStoresSpeedTier = SessionPrefs.gameStoresSpeedTier(this)
|
||||
storesShowMature = SessionPrefs.storesShowMature(this)
|
||||
storesSort = SessionPrefs.storesSort(this)
|
||||
@@ -1175,6 +1283,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
gameDebugLogsEnabled = gameDebugLogsEnabled, gameDebugLogsNeedsRestart = gameDebugLogsNeedsRestart,
|
||||
vacDiagnostics = vacDiagnostics, agentCommands = agentCommands,
|
||||
graphicsLogs = graphicsLogs, steamGpuDrawing = steamGpuDrawing, bridgeFellBack = bridgeFellBack, bridgeFellBackMemory = bridgeFellBackMemory,
|
||||
buildWatermark = buildWatermark,
|
||||
clearCachedApps = clearCachedApps, adbPaired = adbPaired, memoryHud = memoryHud, backgroundAppLimit = backgroundAppLimit,
|
||||
tpUbwcMode = drivers.tpUbwcModeForDevice(), tpUbwcRestartRequired = drivers.tpUbwcRestartRequired(), canRestartApp = !runtimeChangesBlocked(),
|
||||
steamGames = steamGames, steamGamesX64 = steamGamesX64, emulators = emulatorList, running = runningLabel,
|
||||
@@ -1213,6 +1322,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
showPhantomGate = showPhantomGate,
|
||||
orientation = orientation,
|
||||
launcherOrientation = launcherOrientation,
|
||||
homePage = homePage,
|
||||
launcherFullscreen = launcherFullscreen,
|
||||
downloadSource = downloadSource,
|
||||
downloadMirror = downloadMirror,
|
||||
@@ -1222,6 +1332,10 @@ class FrontEndActivity : ComponentActivity() {
|
||||
lowStorageWarning = lowStorageWarning,
|
||||
launcherIcon = launcherIcon,
|
||||
gameStoresEnabled = gameStoresEnabled,
|
||||
soundtracksEnabled = soundtracksEnabled,
|
||||
soundtracksIngame = soundtracksIngame,
|
||||
soundtracks = soundtracks,
|
||||
soundtracksLoaded = soundtracksLoaded,
|
||||
gameStoresSpeedTier = gameStoresSpeedTier,
|
||||
navigate = navRequest,
|
||||
addedGamesArt = addedGamesArt,
|
||||
@@ -1270,7 +1384,10 @@ class FrontEndActivity : ComponentActivity() {
|
||||
},
|
||||
onEpicLauncher = { openEpicLauncher() },
|
||||
onUninstallEpicLauncher = { uninstallEpicLauncher() },
|
||||
onGameShortcut = { g -> com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g) },
|
||||
onGameShortcut = { g ->
|
||||
if (g.soundtrack) com.droiddeck.launcher.frontend.SoundtrackShortcuts.pin(this, g)
|
||||
else com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g)
|
||||
},
|
||||
onExportGameFile = { g -> pickGameExport(g) },
|
||||
onSyncGameFiles = { pickGameExport(null) },
|
||||
onAddGameExe = { path -> addGameExe(path) },
|
||||
@@ -1295,8 +1412,9 @@ class FrontEndActivity : ComponentActivity() {
|
||||
}, "game-file-stop-sync").start()
|
||||
},
|
||||
onCopyGameLink = { g ->
|
||||
(getSystemService(CLIPBOARD_SERVICE) as ClipboardManager).setPrimaryClip(
|
||||
ClipData.newPlainText(g.name, com.droiddeck.launcher.frontend.GameLaunchLink.uri(g.gameIdString)))
|
||||
val link = if (g.soundtrack) com.droiddeck.launcher.frontend.SoundtrackShortcuts.uri(g.appId)
|
||||
else com.droiddeck.launcher.frontend.GameLaunchLink.uri(g.gameIdString)
|
||||
(getSystemService(CLIPBOARD_SERVICE) as ClipboardManager).setPrimaryClip(ClipData.newPlainText(g.name, link))
|
||||
android.widget.Toast.makeText(this, R.string.game_link_copied, android.widget.Toast.LENGTH_SHORT).show()
|
||||
},
|
||||
onDesktop = {
|
||||
@@ -1321,6 +1439,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
},
|
||||
onRom = { g ->
|
||||
val e = emulatorList.first { it.id == g.emulatorId }
|
||||
if (!SessionPrefs.soundtracksIngame(this)) com.droiddeck.launcher.playback.SoundtrackController.pause(this)
|
||||
startActivity(Intent(this, SessionActivity::class.java)
|
||||
.putExtra(SessionService.EXTRA_MODE, SessionService.MODE_RUN)
|
||||
.putExtra(SessionService.EXTRA_PROGRAM, e.program)
|
||||
@@ -1413,6 +1532,11 @@ class FrontEndActivity : ComponentActivity() {
|
||||
SessionPrefs.setDetailedGraphicsLogs(this, !SessionPrefs.detailedGraphicsLogs(this))
|
||||
graphicsLogs = SessionPrefs.detailedGraphicsLogs(this)
|
||||
},
|
||||
onBuildWatermark = {
|
||||
SessionPrefs.setBuildWatermarkEnabled(this, !SessionPrefs.buildWatermarkEnabled(this))
|
||||
buildWatermark = SessionPrefs.buildWatermarkEnabled(this)
|
||||
com.droiddeck.launcher.ui.BuildWatermark.refresh(this)
|
||||
},
|
||||
onVacDiagnostics = {
|
||||
SessionPrefs.setVacDiagnostics(this, !SessionPrefs.vacDiagnostics(this))
|
||||
vacDiagnostics = SessionPrefs.vacDiagnostics(this)
|
||||
@@ -1484,6 +1608,15 @@ class FrontEndActivity : ComponentActivity() {
|
||||
},
|
||||
onPageBack = { showPerformance = false; showComponents = false; showMapping = false },
|
||||
onGameStoresEnabled = { on -> SessionPrefs.setGameStoresEnabled(this, on); gameStoresEnabled = on },
|
||||
onSoundtracksEnabled = { on -> SessionPrefs.setSoundtracksEnabled(this, on); soundtracksEnabled = on },
|
||||
onSoundtracksIngame = { on ->
|
||||
SessionPrefs.setSoundtracksIngame(this, on)
|
||||
soundtracksIngame = on
|
||||
com.droiddeck.launcher.playback.SoundtrackController.setIngame(this, on)
|
||||
},
|
||||
onSoundtrackAdded = { folder -> addSoundtrack(folder) },
|
||||
onSoundtracksChanged = { refreshAddedSoundtracks() },
|
||||
onSoundtrackRemoved = { g -> removeSoundtrack(g) },
|
||||
onTheme = { id -> SessionPrefs.setTheme(this, id); theme = id },
|
||||
onLauncherIcon = { style -> switchLauncherIcon(style) },
|
||||
onLanguage = { tag ->
|
||||
@@ -1505,6 +1638,10 @@ class FrontEndActivity : ComponentActivity() {
|
||||
launcherOrientation = value
|
||||
requestedOrientation = value
|
||||
},
|
||||
onHomePage = { value ->
|
||||
com.droiddeck.launcher.core.AppUiPrefs.setHomePage(this, value)
|
||||
homePage = value
|
||||
},
|
||||
onLauncherFullscreen = { on ->
|
||||
SessionPrefs.setLauncherFullscreen(this, on)
|
||||
launcherFullscreen = on
|
||||
@@ -1573,6 +1710,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
refreshHomeAppState()
|
||||
}
|
||||
},
|
||||
onAppIconsChanged = { refreshAndroidApps() },
|
||||
onAndroidApp = { app, displayId -> launchAndroidApp(app, displayId) },
|
||||
onBackActionsInverted = { inverted ->
|
||||
SessionPrefs.setBackActionsInverted(this, inverted)
|
||||
@@ -1755,6 +1893,8 @@ class FrontEndActivity : ComponentActivity() {
|
||||
}, "finish-abandoned").start()
|
||||
}
|
||||
|
||||
override val petBlocked: Boolean get() = false
|
||||
|
||||
override fun onNewIntent(intent: Intent) {
|
||||
super.onNewIntent(intent)
|
||||
setIntent(intent)
|
||||
@@ -1770,7 +1910,10 @@ class FrontEndActivity : ComponentActivity() {
|
||||
startSteamAtStartupIfEnabled()
|
||||
}
|
||||
|
||||
private var soundtrackLaunch = false
|
||||
|
||||
private fun startSteamAtStartupIfEnabled(cold: Boolean = false) {
|
||||
if (soundtrackLaunch) return
|
||||
if (intent.action != Intent.ACTION_MAIN && !(cold && intent.action == null)) return
|
||||
if (isFinishing || isDestroyed) return
|
||||
when (SessionPrefs.startupSession(this)) {
|
||||
@@ -1848,6 +1991,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
}
|
||||
|
||||
override fun dispatchKeyEvent(event: KeyEvent): Boolean {
|
||||
if (com.droiddeck.launcher.ui.AgentPet.handleBack(this, event)) return true
|
||||
if (compatLaunch != null) {
|
||||
if (event.keyCode == KeyEvent.KEYCODE_BACK || event.keyCode == KeyEvent.KEYCODE_BUTTON_B) {
|
||||
if (event.action == KeyEvent.ACTION_UP) cancelCompatLaunch()
|
||||
@@ -1897,7 +2041,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
orientation = SessionPrefs.orientation(this)
|
||||
launcherOrientation = com.droiddeck.launcher.core.AppUiPrefs.orientation(this)
|
||||
requestedOrientation = launcherOrientation
|
||||
SteamIntegration.syncShortcutsListing(this)
|
||||
homePage = com.droiddeck.launcher.core.AppUiPrefs.homePage(this)
|
||||
refreshWifiDiscovery()
|
||||
com.droiddeck.launcher.stores.StoresState.refresh(this)
|
||||
com.droiddeck.launcher.stores.StoresState.libraryListener = { refreshAddedGames(); refresh() }
|
||||
@@ -1950,6 +2094,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
override fun onStart() {
|
||||
super.onStart()
|
||||
registerReceiver(wifiLocationReceiver, android.content.IntentFilter(android.location.LocationManager.MODE_CHANGED_ACTION))
|
||||
registerReceiver(dateReceiver, android.content.IntentFilter(Intent.ACTION_DATE_CHANGED))
|
||||
registerReceiver(mediaReceiver, android.content.IntentFilter().apply {
|
||||
for (action in listOf(Intent.ACTION_MEDIA_MOUNTED, Intent.ACTION_MEDIA_UNMOUNTED, Intent.ACTION_MEDIA_REMOVED,
|
||||
Intent.ACTION_MEDIA_EJECT, Intent.ACTION_MEDIA_BAD_REMOVAL)) addAction(action)
|
||||
@@ -1995,8 +2140,8 @@ class FrontEndActivity : ComponentActivity() {
|
||||
com.droiddeck.launcher.frontend.AutoComponents.beforeLaunch(this, g, onBlocked = done) {
|
||||
if (request != gameLaunchRequest.get() || isFinishing || isDestroyed) { done(); return@beforeLaunch }
|
||||
com.droiddeck.launcher.stores.StoreLaunch.prepare(this, g) {
|
||||
done()
|
||||
if (request == gameLaunchRequest.get() && !isFinishing && !isDestroyed) launchGame(g)
|
||||
if (request == gameLaunchRequest.get() && !isFinishing && !isDestroyed) launchGame(g, onHandled = done)
|
||||
else done()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2005,6 +2150,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
gameLaunchRequest.incrementAndGet()
|
||||
cancelCompatLaunch()
|
||||
updates.unregister()
|
||||
runCatching { unregisterReceiver(shortcutsInstallStatus) }
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
@@ -2016,6 +2162,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
override fun onStop() {
|
||||
if (!homeChoiceOpen) HomeApp.releaseUnusedHomeEntry(this)
|
||||
unregisterReceiver(wifiLocationReceiver)
|
||||
unregisterReceiver(dateReceiver)
|
||||
unregisterReceiver(mediaReceiver)
|
||||
getSystemService(android.content.pm.LauncherApps::class.java).unregisterCallback(packageCallback)
|
||||
HomeWidgets.stopListening(this)
|
||||
@@ -2392,6 +2539,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
upscaler = upscaler, upscaleSharpness = upscaleSharpness,
|
||||
gpuDrivers = drivers.summary(),
|
||||
touchMode = touchMode,
|
||||
pen = pen,
|
||||
suspendPolicy = suspendPolicy,
|
||||
steamDownloadsInBackground = steamDownloadsInBackground,
|
||||
pipSupported = com.droiddeck.launcher.session.SessionPipController.supported(this),
|
||||
@@ -2444,6 +2592,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
onUpscaler = { m -> SessionPrefs.setUpscaler(this, m); upscaler = m },
|
||||
onUpscaleSharpness = { pct -> SessionPrefs.setUpscaleSharpness(this, pct); upscaleSharpness = pct },
|
||||
onTouch = { t -> SessionPrefs.setTouchMode(this, t); touchMode = t },
|
||||
onPen = { key, value -> SessionPrefs.setPenSetting(this, key, value); pen = SessionPrefs.pen(this) },
|
||||
onSuspendPolicy = { policy -> SessionPrefs.setSuspendPolicy(this, mode, policy); suspendPolicy = policy },
|
||||
onSteamDownloadsInBackground = { enabled ->
|
||||
SessionPrefs.setSteamDownloadsInBackground(this, enabled)
|
||||
@@ -2546,20 +2695,21 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private fun PerformanceHost() {
|
||||
PerformancePage(
|
||||
cores = CpuCores.all.map { c -> CoreRow(c, "cpu$c" + (CpuCores.maxGhz(c)?.let { String.format(java.util.Locale.US, " · %.1f GHz", it) } ?: "")) },
|
||||
clientOverride = clientOverride, clientCores = clientCores, gameCores = gameCores,
|
||||
clientOverride = clientOverride, clientCores = clientCores, gameCores = gameCores, paceCores = paceCores,
|
||||
tuSysmem = tuSysmem, zinkLazy = zinkLazy, glThread = glThread, noGlError = noGlError, noXalia = noXalia,
|
||||
fastSync = fastSync,
|
||||
syncFallback = syncFallback,
|
||||
fsyncFirst = fsyncFirst,
|
||||
gamescopeRealtime = gamescopeRealtime,
|
||||
gpuClockPin = gpuClockPin,
|
||||
ramCapMb = ramCapMb, vramCapMb = vramCapMb, zramClient = zramClient,
|
||||
ramCapMb = ramCapMb, vramCapMb = vramCapMb, zramClient = zramClient, zramIdle = zramIdle,
|
||||
deviceRamMb = (android.app.ActivityManager.MemoryInfo()
|
||||
.also((getSystemService(ACTIVITY_SERVICE) as android.app.ActivityManager)::getMemoryInfo).totalMem / (1024 * 1024)).toInt(),
|
||||
ramCapAvailable = com.droiddeck.launcher.core.ZramSupport.supported(),
|
||||
prootNoSeccomp = prootNoSeccomp, prootFastPath = prootFastPath, cursorComposite = cursorComposite,
|
||||
prootNoSeccomp = prootNoSeccomp, prootFastPath = prootFastPath, nativeUserland = nativeUserland, cursorComposite = cursorComposite,
|
||||
guestHostname = guestHostname, phantomWarning = phantomWarning,
|
||||
onClientOverride = { on -> SessionPrefs.setClientCpusOverride(this, on); clientOverride = on },
|
||||
onPaceCores = { on -> SessionPrefs.setPaceCores(this, on); paceCores = on },
|
||||
onTuSysmem = { on -> SessionPrefs.setTuSysmem(this, on); tuSysmem = on },
|
||||
onZinkLazy = { on -> SessionPrefs.setZinkLazy(this, on); zinkLazy = on },
|
||||
onGlThread = { on -> SessionPrefs.setGlThread(this, on); glThread = on },
|
||||
@@ -2572,9 +2722,11 @@ class FrontEndActivity : ComponentActivity() {
|
||||
onGpuClockPin = { on -> SessionPrefs.setGpuClockPin(this, on); gpuClockPin = on },
|
||||
onRamCapMb = { mb -> SessionPrefs.setRamCapMb(this, mb); ramCapMb = mb },
|
||||
onZramClient = { on -> SessionPrefs.setZramClient(this, on); zramClient = on },
|
||||
onZramIdle = { on -> SessionPrefs.setZramIdle(this, on); zramIdle = on },
|
||||
onVramCapMb = { mb -> SessionPrefs.setVramCapMb(this, mb); vramCapMb = mb },
|
||||
onProotNoSeccomp = { on -> SessionPrefs.setProotNoSeccomp(this, on); prootNoSeccomp = on },
|
||||
onProotFastPath = { on -> SessionPrefs.setProotFastPath(this, on); prootFastPath = on },
|
||||
onNativeUserland = { on -> SessionPrefs.setNativeUserland(this, on); nativeUserland = on },
|
||||
onCursorComposite = { on -> SessionPrefs.setCursorComposite(this, on); cursorComposite = on },
|
||||
onGuestHostname = { name -> SessionPrefs.setGuestHostname(this, name) },
|
||||
onClientCore = { core, on ->
|
||||
@@ -2610,15 +2762,89 @@ class FrontEndActivity : ComponentActivity() {
|
||||
val version = (steamArtRefreshes[appId] ?: 0) + 1
|
||||
steamArtRefreshes[appId] = version
|
||||
Thread({
|
||||
val fresh = com.droiddeck.launcher.frontend.Library.steamGames(this).firstOrNull { it.appId == appId } ?: return@Thread
|
||||
val fresh = com.droiddeck.launcher.frontend.Library.steamGames(this, soundtracks = true).firstOrNull { it.appId == appId } ?: return@Thread
|
||||
ui.post {
|
||||
if (steamArtRefreshes[appId] != version) return@post
|
||||
steamGames = steamGames.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it }
|
||||
if (fresh.soundtrack) soundtracks = soundtracks.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it }
|
||||
else steamGames = steamGames.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it }
|
||||
}
|
||||
}, "steam-art-update").start()
|
||||
}
|
||||
|
||||
private fun addSoundtrack(folder: java.io.File) {
|
||||
val op = ++soundtrackOp
|
||||
soundtrackAddScan = libraryScanGeneration
|
||||
soundtrackWork.execute {
|
||||
val added = com.droiddeck.launcher.frontend.AddedSoundtracks.add(this, folder)
|
||||
val list = com.droiddeck.launcher.frontend.AddedSoundtracks.games(this)
|
||||
ui.post {
|
||||
if (added) {
|
||||
soundtrackRemovals[folder.path]?.takeIf { it.op < op }?.let {
|
||||
soundtrackRemovals.remove(folder.path)
|
||||
com.droiddeck.launcher.playback.SoundtrackController.allow(listOf(folder.path))
|
||||
}
|
||||
val visible = list.filterNot { s -> s.gameFiles?.path?.let { soundtrackRemovals[it] }?.let { it.op > op } == true }
|
||||
soundtracks = soundtracks.filter { it.library != Library.ADDED } + visible
|
||||
} else android.widget.Toast.makeText(this, R.string.soundtracks_add_empty, android.widget.Toast.LENGTH_SHORT).show()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun refreshAddedSoundtracks() {
|
||||
val op = soundtrackOp
|
||||
soundtrackWork.execute {
|
||||
val list = com.droiddeck.launcher.frontend.AddedSoundtracks.games(this)
|
||||
ui.post {
|
||||
if (op != soundtrackOp) return@post
|
||||
val visible = list.filterNot { s -> s.gameFiles?.path?.let { soundtrackRemovals[it] } != null }
|
||||
soundtracks = soundtracks.filter { it.library != Library.ADDED } + visible
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun removeSoundtrack(g: Library.SteamGame) {
|
||||
val path = g.gameFiles?.path
|
||||
val added = g.library == Library.ADDED
|
||||
val target = if (added) null else com.droiddeck.launcher.frontend.GameRemoval.steamFiles(g) ?: return
|
||||
com.droiddeck.launcher.playback.SoundtrackController.stopIf(this, g.gameFiles)
|
||||
val marker = SoundtrackRemoval(++soundtrackOp, libraryScanGeneration, added)
|
||||
path?.let { soundtrackRemovals[it] = marker }
|
||||
if (target == null) {
|
||||
soundtracks = soundtracks.filterNot { it.appId == g.appId && it.library == Library.ADDED }
|
||||
soundtrackWork.execute {
|
||||
val removed = com.droiddeck.launcher.frontend.AddedSoundtracks.remove(this, path.orEmpty())
|
||||
val list = if (removed) emptyList() else com.droiddeck.launcher.frontend.AddedSoundtracks.games(this)
|
||||
if (!removed) ui.post {
|
||||
if (path != null && soundtrackRemovals[path] === marker) {
|
||||
soundtrackRemovals.remove(path)
|
||||
com.droiddeck.launcher.playback.SoundtrackController.allow(listOf(path))
|
||||
}
|
||||
soundtracks = soundtracks.filter { it.library != Library.ADDED } + list.filterNot { s -> s.gameFiles?.path?.let { soundtrackRemovals[it] } != null }
|
||||
android.widget.Toast.makeText(this, getString(R.string.gfiles_remove_failed, g.name), android.widget.Toast.LENGTH_SHORT).show()
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
soundtrackWork.execute {
|
||||
val deleted = com.droiddeck.launcher.frontend.GameRemoval.delete(target)
|
||||
ui.post {
|
||||
if (deleted) {
|
||||
marker.scan = libraryScanGeneration
|
||||
marker.settled = true
|
||||
} else {
|
||||
if (path != null && soundtrackRemovals[path] === marker) {
|
||||
soundtrackRemovals.remove(path)
|
||||
com.droiddeck.launcher.playback.SoundtrackController.allow(listOf(path))
|
||||
}
|
||||
android.widget.Toast.makeText(this, getString(R.string.gfiles_remove_failed, g.name), android.widget.Toast.LENGTH_SHORT).show()
|
||||
}
|
||||
refresh()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun removeGame(g: Library.SteamGame) {
|
||||
if (g.soundtrack) { removeSoundtrack(g); return }
|
||||
val folder = g.gameFiles ?: return
|
||||
when (com.droiddeck.launcher.frontend.GameRemoval.kind(g)) {
|
||||
com.droiddeck.launcher.frontend.GameRemoval.Kind.LAUNCHER -> Unit
|
||||
@@ -2714,6 +2940,8 @@ class FrontEndActivity : ComponentActivity() {
|
||||
upscaleSharpness = SessionPrefs.upscaleSharpness(this)
|
||||
hdrReason = com.droiddeck.launcher.wayland.HdrSupport.probe(this).reason
|
||||
touchMode = SessionPrefs.touchMode(this)
|
||||
if (!SessionPrefs.penSeen(this) && com.droiddeck.launcher.input.PenStream.penConnected()) SessionPrefs.setPenSeen(this)
|
||||
pen = SessionPrefs.pen(this).takeIf { SessionPrefs.penSeen(this) }
|
||||
suspendPolicy = SessionPrefs.suspendPolicy(this, mode)
|
||||
steamDownloadsInBackground = SessionPrefs.steamDownloadsInBackground(this)
|
||||
oscMode = SessionPrefs.oscMode(this)
|
||||
@@ -2791,12 +3019,15 @@ class FrontEndActivity : ComponentActivity() {
|
||||
syncFallback = SessionPrefs.syncFallback(this)
|
||||
fsyncFirst = SessionPrefs.fsyncFirst(this)
|
||||
gamescopeRealtime = SessionPrefs.gamescopeRealtime(this)
|
||||
paceCores = SessionPrefs.paceCores(this)
|
||||
ramCapMb = SessionPrefs.ramCapMb(this)
|
||||
zramClient = SessionPrefs.zramClient(this)
|
||||
zramIdle = SessionPrefs.zramIdle(this)
|
||||
vramCapMb = SessionPrefs.vramCapMb(this)
|
||||
gpuClockPin = SessionPrefs.gpuClockPin(this)
|
||||
prootNoSeccomp = SessionPrefs.prootNoSeccomp(this)
|
||||
prootFastPath = SessionPrefs.prootFastPath(this)
|
||||
nativeUserland = SessionPrefs.nativeUserland(this)
|
||||
cursorComposite = SessionPrefs.cursorComposite(this)
|
||||
guestHostname = SessionPrefs.guestHostname(this)
|
||||
refreshPhantomStatus()
|
||||
@@ -2862,6 +3093,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
vacDiagnostics = SessionPrefs.vacDiagnostics(this)
|
||||
agentCommands = com.droiddeck.launcher.agent.AgentAccess.commandsEnabled(this)
|
||||
graphicsLogs = SessionPrefs.detailedGraphicsLogs(this)
|
||||
buildWatermark = SessionPrefs.buildWatermarkEnabled(this)
|
||||
steamGpuDrawing = SessionPrefs.steamGpuCompositing(this)
|
||||
bridgeFellBack = SessionPrefs.bridgeFellBack(this)
|
||||
bridgeFellBackMemory = SessionPrefs.bridgeFellBackForMemory(this)
|
||||
@@ -2900,6 +3132,19 @@ class FrontEndActivity : ComponentActivity() {
|
||||
}
|
||||
val scannedArch = SessionPrefs.activeSteamClientArch(this)
|
||||
val scannedX64 = scannedArch == "x86_64"
|
||||
val scannedSoundtracks = runCatching {
|
||||
(if (ready || com.droiddeck.launcher.runtime.LinuxRuntime.hasRootfs(this)) Library.soundtracks(this, scannedArch) else emptyList()) +
|
||||
com.droiddeck.launcher.frontend.AddedSoundtracks.games(this)
|
||||
}.getOrDefault(emptyList())
|
||||
ui.post {
|
||||
if (scanGeneration == libraryScanGeneration) {
|
||||
val scanned = if (scanGeneration <= soundtrackAddScan) scannedSoundtracks + soundtracks.filter { cur -> cur.library == Library.ADDED && scannedSoundtracks.none { it.library == Library.ADDED && it.appId == cur.appId } } else scannedSoundtracks
|
||||
val kept = scanned.filterNot { s -> s.gameFiles?.path?.let { p -> soundtrackRemovals[p]?.let { m -> !m.settled || s.library == Library.ADDED || scanGeneration <= m.scan } } == true }
|
||||
com.droiddeck.launcher.playback.SoundtrackController.allow(kept.mapNotNull { it.gameFiles?.path })
|
||||
soundtracks = kept
|
||||
soundtracksLoaded = true
|
||||
}
|
||||
}
|
||||
val games = if (ready || com.droiddeck.launcher.runtime.LinuxRuntime.hasRootfs(this)) Library.launchableGames(this, arch = scannedArch) else emptyList()
|
||||
val all = games.distinctBy { it.gameId }
|
||||
if (ready && scanGeneration == libraryScanGeneration) com.droiddeck.launcher.frontend.LibraryCache.save(this, all, scannedX64)
|
||||
@@ -3041,6 +3286,8 @@ class FrontEndActivity : ComponentActivity() {
|
||||
com.droiddeck.launcher.core.AppLanguage.setChosen(this, com.droiddeck.launcher.core.AppLanguage.SYSTEM)
|
||||
if (!ok) android.widget.Toast.makeText(this, R.string.setup_reset_settings_partial, android.widget.Toast.LENGTH_LONG).show()
|
||||
com.droiddeck.launcher.ui.Motion.refresh(this)
|
||||
com.droiddeck.launcher.agent.AgentTab.load(this)
|
||||
com.droiddeck.launcher.ui.NavTabs.load(this)
|
||||
if (!switchLauncherIcon(LauncherIcon.DARK)) recreate()
|
||||
}
|
||||
}, "reset-settings").start()
|
||||
@@ -3076,6 +3323,7 @@ class FrontEndActivity : ComponentActivity() {
|
||||
android.widget.Toast.makeText(this, it, android.widget.Toast.LENGTH_LONG).show()
|
||||
}
|
||||
refresh()
|
||||
com.droiddeck.launcher.agent.AgentHost.refresh(this)
|
||||
if (ok == true && LinuxRuntime.isInstalled(this)) protons.checkUpdates()
|
||||
}
|
||||
}, "runtime-operation").start()
|
||||
@@ -3126,3 +3374,9 @@ class FrontEndActivity : ComponentActivity() {
|
||||
private val WCP_EXT = listOf("wcp")
|
||||
}
|
||||
}
|
||||
|
||||
// The install session outlives the activity when Android recreates it mid-install.
|
||||
private object ShortcutsInstall {
|
||||
@Volatile var session = -1
|
||||
@Volatile var running = false
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import android.app.Activity
|
||||
import android.content.Intent
|
||||
import android.os.Bundle
|
||||
import com.droiddeck.launcher.session.SessionService
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
|
||||
class HomeActivity : Activity() {
|
||||
override fun attachBaseContext(newBase: android.content.Context) {
|
||||
@@ -18,15 +19,22 @@ class HomeActivity : Activity() {
|
||||
}
|
||||
|
||||
private fun routeHome() {
|
||||
val destination = if (HomeApp.isActiveSteamSession()) {
|
||||
val destination = if (HomeApp.isActiveSteamSession() && !SessionState.pipActive) {
|
||||
Intent(this, SessionActivity::class.java)
|
||||
.setAction(SessionService.ACTION_HOME_GUIDE)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||
} else {
|
||||
Intent(this, FrontEndActivity::class.java)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||
.apply {
|
||||
val page = com.droiddeck.launcher.core.AppUiPrefs.homePage(this@HomeActivity)
|
||||
if (page != com.droiddeck.launcher.core.AppUiPrefs.HOME_PAGE_STEAM) {
|
||||
putExtra(com.droiddeck.launcher.stores.download.StoreDownloadService.EXTRA_NAV, page)
|
||||
}
|
||||
}
|
||||
}
|
||||
startActivity(destination)
|
||||
if (SessionState.pipActive && destination.component?.className == FrontEndActivity::class.java.name) HomeApp.showFrontEnd(this, destination)
|
||||
else startActivity(destination)
|
||||
finish()
|
||||
}
|
||||
}
|
||||
@@ -18,6 +18,7 @@ import android.net.Uri
|
||||
import android.os.Build
|
||||
import android.provider.Settings
|
||||
import androidx.core.graphics.drawable.toBitmap
|
||||
import com.droiddeck.launcher.core.AppUiPrefs
|
||||
import com.droiddeck.launcher.session.SessionService
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
import kotlin.math.roundToInt
|
||||
@@ -41,7 +42,7 @@ object HomeApp {
|
||||
val userSerial: Long = 0L,
|
||||
) {
|
||||
val component get() = ComponentName(packageName, className)
|
||||
val key get() = "$packageName/$className" + if (userSerial != 0L) "#$userSerial" else ""
|
||||
val key get() = appKey(packageName, className, userSerial)
|
||||
val work get() = userSerial != 0L
|
||||
}
|
||||
|
||||
@@ -101,6 +102,9 @@ object HomeApp {
|
||||
?: resolved.loadLabel(pm)?.toString()?.trim()?.takeIf { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
private fun appKey(packageName: String, className: String, userSerial: Long) =
|
||||
"$packageName/$className" + if (userSerial != 0L) "#$userSerial" else ""
|
||||
|
||||
fun roleRequestIntent(context: Context): Intent? {
|
||||
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return null
|
||||
val roles = context.getSystemService(RoleManager::class.java) ?: return null
|
||||
@@ -116,13 +120,25 @@ object HomeApp {
|
||||
val pm = context.packageManager
|
||||
val own = Process.myUserHandle()
|
||||
val iconPx = (ICON_DP * context.resources.displayMetrics.density).roundToInt()
|
||||
val densityDpi = context.resources.displayMetrics.densityDpi
|
||||
val pack = IconPack.active(context)
|
||||
val appColors = IconPack.appColors(context)
|
||||
HomeIcons.load(context)
|
||||
val overrides = HomeIcons.overrides
|
||||
val apps = users.userProfiles.flatMap { user ->
|
||||
val serial = if (user == own) 0L else users.getSerialNumberForUser(user)
|
||||
runCatching { launcher.getActivityList(null, user) }.getOrDefault(emptyList()).mapNotNull { info ->
|
||||
val component = info.componentName
|
||||
if (component.packageName == context.packageName && user == own) return@mapNotNull null
|
||||
val label = info.label?.toString()?.trim().orEmpty().ifEmpty { component.packageName }
|
||||
val icon = runCatching { info.getBadgedIcon(0).toBitmap(iconPx, iconPx) }.getOrNull()
|
||||
val icon = runCatching {
|
||||
(overrides[appKey(component.packageName, component.className, serial)]
|
||||
?.let { IconPack.drawable(context, it.pack, it.drawable, densityDpi) }
|
||||
?: pack?.icon(component, densityDpi)
|
||||
?: pack?.plated(info.getIcon(0), iconPx, densityDpi, appColors))
|
||||
?.let { pm.getUserBadgedIcon(it, user) }
|
||||
?.toBitmap(iconPx, iconPx)
|
||||
}.getOrNull() ?: runCatching { info.getBadgedIcon(0).toBitmap(iconPx, iconPx) }.getOrNull()
|
||||
val app = info.applicationInfo
|
||||
val updated = if (user == own) runCatching { pm.getPackageInfo(component.packageName, 0).lastUpdateTime }.getOrNull() else null
|
||||
@Suppress("DEPRECATION")
|
||||
@@ -181,7 +197,10 @@ object HomeApp {
|
||||
}
|
||||
|
||||
private fun syncRecents(activity: android.app.Activity) =
|
||||
keepOutOfRecents(activity, activity is FrontEndActivity && !SessionState.running && isDefault(activity))
|
||||
keepOutOfRecents(
|
||||
activity,
|
||||
activity is FrontEndActivity && !SessionState.running && isDefault(activity) && AppUiPrefs.hideHomeFromRecents(activity),
|
||||
)
|
||||
|
||||
internal enum class RecentsStep { HIDE, SHOW, FORGET, NONE }
|
||||
|
||||
@@ -243,6 +262,19 @@ object HomeApp {
|
||||
fun isActiveSteamSession(): Boolean =
|
||||
SessionState.running && SessionState.mode == SessionService.MODE_STEAM
|
||||
|
||||
fun showFrontEnd(context: Context, intent: Intent = Intent(context, FrontEndActivity::class.java)) {
|
||||
val frontEnd = FrontEndActivity::class.java.name
|
||||
val tasks = runCatching { context.getSystemService(android.app.ActivityManager::class.java)?.appTasks }.getOrNull().orEmpty()
|
||||
val own = tasks.firstOrNull { task ->
|
||||
runCatching { task.taskInfo.let { it.baseIntent.component?.className == frontEnd && it.topActivity?.className == frontEnd } }
|
||||
.getOrDefault(false)
|
||||
}
|
||||
val launch = Intent(intent).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||
if (own != null && runCatching { own.startActivity(context, launch, null) }.isSuccess) return
|
||||
// The session task shares the front end's affinity, so without MULTIPLE_TASK the front end lands inside the session's PiP window.
|
||||
context.startActivity(launch.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK))
|
||||
}
|
||||
|
||||
fun openSystemHomeSettings(context: Context) {
|
||||
try {
|
||||
context.startActivity(settingsIntent())
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
package com.droiddeck.launcher
|
||||
|
||||
import android.content.Context
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
|
||||
object HomeIcons {
|
||||
private const val PREFS = "home_launcher"
|
||||
private const val KEY = "icon_overrides"
|
||||
private const val SEPARATOR = '\t'
|
||||
|
||||
data class Choice(val pack: String, val drawable: String)
|
||||
|
||||
var overrides by mutableStateOf<Map<String, Choice>>(emptyMap())
|
||||
private set
|
||||
@Volatile private var loaded = false
|
||||
|
||||
@Synchronized
|
||||
fun load(context: Context) {
|
||||
if (loaded) return
|
||||
overrides = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
|
||||
.getStringSet(KEY, emptySet()).orEmpty().mapNotNull(::decode).toMap()
|
||||
loaded = true
|
||||
}
|
||||
|
||||
fun set(context: Context, key: String, pack: String, drawable: String) = save(context, overrides + (key to Choice(pack, drawable)))
|
||||
|
||||
fun clear(context: Context, key: String) = save(context, overrides - key)
|
||||
|
||||
fun clearAll(context: Context) = save(context, emptyMap())
|
||||
|
||||
private fun save(context: Context, next: Map<String, Choice>) {
|
||||
overrides = next
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.putStringSet(KEY, next.map { (key, choice) -> encode(key, choice) }.toSet()).apply()
|
||||
}
|
||||
|
||||
internal fun encode(key: String, choice: Choice) = listOf(key, choice.pack, choice.drawable).joinToString(SEPARATOR.toString())
|
||||
|
||||
internal fun decode(entry: String): Pair<String, Choice>? {
|
||||
val parts = entry.split(SEPARATOR)
|
||||
if (parts.size != 3 || parts.any { it.isEmpty() }) return null
|
||||
return parts[0] to Choice(parts[1], parts[2])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
package com.droiddeck.launcher
|
||||
|
||||
import android.content.ComponentName
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.PackageManager
|
||||
import android.content.res.Resources
|
||||
import android.graphics.Bitmap
|
||||
import android.graphics.Canvas
|
||||
import android.graphics.Paint
|
||||
import android.graphics.PorterDuff
|
||||
import android.graphics.PorterDuffColorFilter
|
||||
import android.graphics.PorterDuffXfermode
|
||||
import android.graphics.Rect
|
||||
import android.graphics.drawable.Drawable
|
||||
import android.util.Xml
|
||||
import androidx.core.content.res.ResourcesCompat
|
||||
import androidx.core.graphics.createBitmap
|
||||
import androidx.core.graphics.drawable.toBitmap
|
||||
import androidx.core.graphics.drawable.toDrawable
|
||||
import androidx.palette.graphics.Palette
|
||||
import org.xmlpull.v1.XmlPullParser
|
||||
import java.time.LocalDate
|
||||
import kotlin.math.roundToInt
|
||||
|
||||
object IconPack {
|
||||
const val NONE = ""
|
||||
private const val PREFS = "home_launcher"
|
||||
private const val KEY = "icon_pack"
|
||||
private const val APP_COLORS = "icon_pack_app_colors"
|
||||
private const val FILTER = "appfilter"
|
||||
private const val DRAWABLES = "drawable"
|
||||
|
||||
private val ACTIONS = listOf("org.adw.launcher.THEMES", "com.novalauncher.THEME")
|
||||
|
||||
data class Pack(val packageName: String, val label: String)
|
||||
|
||||
internal data class Plate(val back: String?, val mask: String?, val upon: String?, val scale: Float)
|
||||
|
||||
internal data class Filter(val icons: Map<String, String>, val calendars: Map<String, String>, val plate: Plate?) {
|
||||
fun names(component: String, day: Int) = listOfNotNull(calendars[component]?.plus(day), icons[component])
|
||||
}
|
||||
|
||||
class Loaded internal constructor(
|
||||
private val resources: Resources,
|
||||
internal val pack: String,
|
||||
internal val updatedAt: Long,
|
||||
private val filter: Filter,
|
||||
) {
|
||||
fun icon(component: ComponentName, densityDpi: Int) =
|
||||
filter.names(component.flattenToString(), LocalDate.now().dayOfMonth).firstNotNullOfOrNull { load(resources, pack, it, densityDpi) }
|
||||
|
||||
val hasBack get() = filter.plate?.back != null
|
||||
|
||||
fun plated(icon: Drawable, size: Int, densityDpi: Int, appColor: Boolean): Drawable? {
|
||||
val plate = filter.plate ?: return null
|
||||
fun image(name: String?) = name?.let { load(resources, pack, it, densityDpi) }?.toBitmap(size, size)
|
||||
val base = icon.toBitmap(size, size)
|
||||
val color = if (appColor) Palette.from(base).generate().getDominantColor(0).takeIf { it != 0 } else null
|
||||
return compose(base, image(plate.back), image(plate.mask), image(plate.upon), plate.scale, color).toDrawable(resources)
|
||||
}
|
||||
}
|
||||
|
||||
@Volatile private var cached: Loaded? = null
|
||||
|
||||
fun selected(context: Context): String =
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString(KEY, NONE).orEmpty()
|
||||
|
||||
fun select(context: Context, pack: String) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().putString(KEY, pack).apply()
|
||||
}
|
||||
|
||||
fun appColors(context: Context): Boolean =
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getBoolean(APP_COLORS, false)
|
||||
|
||||
fun setAppColors(context: Context, on: Boolean) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().putBoolean(APP_COLORS, on).apply()
|
||||
}
|
||||
|
||||
fun installed(context: Context): List<Pack> {
|
||||
val pm = context.packageManager
|
||||
return ACTIONS.flatMap { pm.queryIntentActivities(Intent(it), 0) }
|
||||
.map { it.activityInfo.applicationInfo }
|
||||
.distinctBy { it.packageName }
|
||||
.filter { app -> resources(pm, app.packageName)?.let { withXml(it, app.packageName, FILTER) { true } } == true }
|
||||
.map { app -> Pack(app.packageName, app.loadLabel(pm).toString().trim().ifEmpty { app.packageName }) }
|
||||
.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.label })
|
||||
}
|
||||
|
||||
fun active(context: Context): Loaded? {
|
||||
val pack = selected(context)
|
||||
if (pack == NONE) return null
|
||||
val pm = context.packageManager
|
||||
val updatedAt = runCatching { pm.getPackageInfo(pack, 0).lastUpdateTime }.getOrNull() ?: return null
|
||||
cached?.takeIf { it.pack == pack && it.updatedAt == updatedAt }?.let { return it }
|
||||
val resources = resources(pm, pack) ?: return null
|
||||
val filter = withXml(resources, pack, FILTER) { parse(it) } ?: return null
|
||||
return Loaded(resources, pack, updatedAt, filter).also { cached = it }
|
||||
}
|
||||
|
||||
fun drawable(context: Context, pack: String, name: String, densityDpi: Int): Drawable? {
|
||||
val resources = resources(context.packageManager, pack) ?: return null
|
||||
return load(resources, pack, name, densityDpi)
|
||||
}
|
||||
|
||||
fun names(context: Context, pack: String): List<String> {
|
||||
val resources = resources(context.packageManager, pack) ?: return emptyList()
|
||||
return withXml(resources, pack, DRAWABLES) { parseNames(it) }?.takeIf { it.isNotEmpty() }
|
||||
?: withXml(resources, pack, FILTER) { parse(it).icons.values.distinct().sorted() }.orEmpty()
|
||||
}
|
||||
|
||||
private fun resources(pm: PackageManager, pack: String): Resources? =
|
||||
runCatching { pm.getResourcesForApplication(pack) }.getOrNull()
|
||||
|
||||
private fun load(resources: Resources, pack: String, name: String, densityDpi: Int): Drawable? {
|
||||
val id = resources.getIdentifier(name, "drawable", pack).takeIf { it != 0 }
|
||||
?: resources.getIdentifier(name, "mipmap", pack).takeIf { it != 0 }
|
||||
?: return null
|
||||
return runCatching { ResourcesCompat.getDrawableForDensity(resources, id, densityDpi, null) }.getOrNull()
|
||||
}
|
||||
|
||||
internal fun parseNames(xml: XmlPullParser): List<String> {
|
||||
val names = LinkedHashSet<String>()
|
||||
forEachTag(xml) { if (xml.name == "item") xml.getAttributeValue(null, "drawable")?.trim()?.takeIf { it.isNotEmpty() }?.let { names.add(it) } }
|
||||
return names.toList()
|
||||
}
|
||||
|
||||
internal fun parse(xml: XmlPullParser): Filter {
|
||||
val icons = HashMap<String, String>()
|
||||
val calendars = HashMap<String, String>()
|
||||
var back: String? = null
|
||||
var mask: String? = null
|
||||
var upon: String? = null
|
||||
var scale = 1f
|
||||
fun image() = xml.getAttributeValue(null, "img1")?.trim()?.takeIf { it.isNotEmpty() }
|
||||
forEachTag(xml) {
|
||||
when (xml.name) {
|
||||
"item" -> {
|
||||
val key = componentKey(xml.getAttributeValue(null, "component"))
|
||||
val drawable = xml.getAttributeValue(null, "drawable")?.trim()
|
||||
if (key != null && !drawable.isNullOrEmpty()) icons.putIfAbsent(key, drawable)
|
||||
}
|
||||
"calendar" -> {
|
||||
val key = componentKey(xml.getAttributeValue(null, "component"))
|
||||
val prefix = xml.getAttributeValue(null, "prefix")?.trim()
|
||||
if (key != null && !prefix.isNullOrEmpty()) calendars.putIfAbsent(key, prefix)
|
||||
}
|
||||
"iconback" -> back = back ?: image()
|
||||
"iconmask" -> mask = mask ?: image()
|
||||
"iconupon" -> upon = upon ?: image()
|
||||
"scale" -> scale = xml.getAttributeValue(null, "factor")?.toFloatOrNull() ?: scale
|
||||
}
|
||||
}
|
||||
return Filter(icons, calendars, if (back == null && mask == null && upon == null) null else Plate(back, mask, upon, scale))
|
||||
}
|
||||
|
||||
internal fun compose(icon: Bitmap, back: Bitmap?, mask: Bitmap?, upon: Bitmap?, scale: Float, backColor: Int? = null): Bitmap {
|
||||
val size = icon.width
|
||||
val inset = (size * (1 - scale) / 2).roundToInt()
|
||||
val result = createBitmap(size, size)
|
||||
val canvas = Canvas(result)
|
||||
val paint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG)
|
||||
val full = Rect(0, 0, size, size)
|
||||
canvas.drawBitmap(icon, null, Rect(inset, inset, size - inset, size - inset), paint)
|
||||
mask?.let {
|
||||
paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OUT)
|
||||
canvas.drawBitmap(it, null, full, paint)
|
||||
}
|
||||
back?.let {
|
||||
paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER)
|
||||
paint.colorFilter = backColor?.let { color -> PorterDuffColorFilter(color, PorterDuff.Mode.SRC_IN) }
|
||||
canvas.drawBitmap(it, null, full, paint)
|
||||
}
|
||||
paint.xfermode = null
|
||||
paint.colorFilter = null
|
||||
upon?.let { canvas.drawBitmap(it, null, full, paint) }
|
||||
return result
|
||||
}
|
||||
|
||||
private inline fun forEachTag(xml: XmlPullParser, block: () -> Unit) {
|
||||
var event = xml.eventType
|
||||
while (event != XmlPullParser.END_DOCUMENT) {
|
||||
if (event == XmlPullParser.START_TAG) block()
|
||||
event = xml.next()
|
||||
}
|
||||
}
|
||||
|
||||
internal fun componentKey(component: String?): String? =
|
||||
component?.trim()?.removePrefix("ComponentInfo{")?.removeSuffix("}")?.let(ComponentName::unflattenFromString)?.flattenToString()
|
||||
|
||||
private fun <T> withXml(resources: Resources, pack: String, file: String, block: (XmlPullParser) -> T): T? = runCatching {
|
||||
val xml = resources.getIdentifier(file, "xml", pack)
|
||||
val raw = resources.getIdentifier(file, "raw", pack)
|
||||
if (xml != 0) resources.getXml(xml).use(block)
|
||||
else (if (raw != 0) resources.openRawResource(raw) else resources.assets.open("$file.xml"))
|
||||
.use { stream -> block(Xml.newPullParser().also { it.setInput(stream, null) }) }
|
||||
}.getOrNull()
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package com.droiddeck.launcher
|
||||
|
||||
internal object MaliAutoRoute {
|
||||
const val NONE = ""
|
||||
const val BRIDGE = "bridge"
|
||||
const val VENUS = "venus"
|
||||
|
||||
fun initialOwnership(bridgeOn: Boolean, bridgeExplicit: Boolean, venusOn: Boolean, venusExplicit: Boolean): String =
|
||||
when {
|
||||
venusOn && !venusExplicit -> VENUS
|
||||
bridgeOn && !bridgeExplicit -> BRIDGE
|
||||
else -> NONE
|
||||
}
|
||||
|
||||
fun fallbackOwnership(
|
||||
venusAvailable: Boolean,
|
||||
bridgeOn: Boolean,
|
||||
bridgeExplicit: Boolean,
|
||||
venusOn: Boolean,
|
||||
venusExplicit: Boolean,
|
||||
): String = if (venusAvailable) {
|
||||
if (!venusOn || !venusExplicit) VENUS else NONE
|
||||
} else {
|
||||
if (!bridgeOn || !bridgeExplicit) BRIDGE else NONE
|
||||
}
|
||||
|
||||
fun userChoice(keyStored: Boolean, owner: String, route: String): Boolean = keyStored && owner != route
|
||||
|
||||
fun shouldEnd(ownsRoute: String, mali: Boolean, installedPair: Boolean): Boolean =
|
||||
mali && installedPair && ownsRoute != NONE
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -17,6 +17,7 @@ import com.droiddeck.launcher.ui.UpdatesActions
|
||||
import com.droiddeck.launcher.ui.UpdatesState
|
||||
import com.droiddeck.launcher.update.AppUpdates
|
||||
import com.droiddeck.launcher.update.SelfInstaller
|
||||
import com.droiddeck.launcher.update.UpdateWatch
|
||||
|
||||
internal class UpdatesMenu(private val activity: Activity, private val ui: Handler) {
|
||||
var catalog by mutableStateOf<AppUpdates.Catalog?>(null)
|
||||
@@ -43,6 +44,7 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl
|
||||
.onFailure { error = activity.getString(R.string.upd_unknown_apps_failed); pending = null }
|
||||
},
|
||||
onDismissPermission = { askPermission = false; pending = null },
|
||||
onSeen = { r -> UpdateWatch.seen(activity, r) },
|
||||
)
|
||||
|
||||
val hasUpdate: Boolean get() = AppUpdates.hasUpdate(catalog, follow)
|
||||
@@ -77,6 +79,7 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl
|
||||
|
||||
private fun choose(f: AppUpdates.Follow) {
|
||||
AppUpdates.setFollow(activity, f)
|
||||
UpdateWatch.sync(activity, f, catalog?.let { AppUpdates.release(it, f) })
|
||||
follow = f
|
||||
error = null
|
||||
}
|
||||
@@ -93,7 +96,17 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl
|
||||
percent = 0
|
||||
Thread({
|
||||
val result = runCatching {
|
||||
val file = SelfInstaller.download(activity, apk) { pct -> ui.post { percent = pct } }
|
||||
val file = try {
|
||||
SelfInstaller.download(activity, apk) { pct -> ui.post { percent = pct } }
|
||||
} catch (e: java.io.IOException) {
|
||||
// Each push replaces a test build's APK, so a list read before the push names a file that is gone.
|
||||
if (r.pr <= 0) throw e
|
||||
val fresh = runCatching { AppUpdates.refresh(activity) }.getOrNull() ?: throw e
|
||||
ui.post { catalog = fresh }
|
||||
val newer = fresh.tests.firstOrNull { it.tag == r.tag }?.apk?.takeIf { it.url != apk.url } ?: throw e
|
||||
ui.post { percent = 0 }
|
||||
SelfInstaller.download(activity, newer) { pct -> ui.post { percent = pct } }
|
||||
}
|
||||
ui.post { stage = activity.getString(R.string.upd_stage_installing); percent = -1 }
|
||||
SelfInstaller.install(activity, file) { id -> session = id }
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ object AgentAccess {
|
||||
fun requireCommands(context: Context) {
|
||||
if (!commandsAllowed(context)) throw AgentException(
|
||||
"AGENT_COMMANDS_DISABLED",
|
||||
"Debugging tools are off: turn on Setup > Diagnostics > Debugging tools on the device",
|
||||
"Debugging tools are off: turn on Setup > Developer > Debugging tools on the device",
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import com.droiddeck.launcher.core.WirelessAdbFix
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* Loopback adb for the agent, so droiddeckctl in the Linux userland reaches the app. It reuses
|
||||
* the Wireless debugging pairing DroidDeck already made (for the phantom process fix): the paired
|
||||
* key goes to the guest as an adb vendor key, and the serial is the paired TLS connect port.
|
||||
* Without a pairing it falls back to adbd on 127.0.0.1:5555, which some devices and `adb tcpip`
|
||||
* leave listening.
|
||||
*/
|
||||
object AgentAdb {
|
||||
data class Link(val serial: String, val vendorKeys: String, val paired: Boolean)
|
||||
|
||||
private const val LEGACY = "127.0.0.1:5555"
|
||||
private const val VENDOR_KEY = "/root/.android/droiddeck-paired.adbkey"
|
||||
|
||||
/** The display the browser opens on for sign-ins: the one the agent is being used on. */
|
||||
@Volatile var browserDisplay = 0
|
||||
|
||||
/** Blocks while it looks up the connect port when none is saved; call it off the main thread. */
|
||||
fun prepare(app: Context): Link {
|
||||
val key = File(app.noBackupFilesDir, "wireless-adb-key.pem")
|
||||
val address = WirelessAdbFix.liveConnectAddress(app) ?: WirelessAdbFix.savedConnectionAddress(app)
|
||||
if (address == null || !key.isFile) return Link(LEGACY, VENDOR_KEY, false)
|
||||
val guestKey = File(LinuxRuntime.rootDir(app), VENDOR_KEY.removePrefix("/"))
|
||||
runCatching {
|
||||
if (!guestKey.isFile || !guestKey.readBytes().contentEquals(key.readBytes())) {
|
||||
guestKey.parentFile?.mkdirs()
|
||||
guestKey.writeBytes(key.readBytes())
|
||||
guestKey.setReadable(false, false)
|
||||
guestKey.setReadable(true, true)
|
||||
}
|
||||
}
|
||||
val host = address.substringBeforeLast(':')
|
||||
val port = address.substringAfterLast(':').toIntOrNull()
|
||||
?: WirelessAdbFix.findConnectPort(app, host.trim('[', ']'))
|
||||
?: return Link(LEGACY, VENDOR_KEY, false)
|
||||
return Link("$host:$port", VENDOR_KEY, true)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import android.graphics.Bitmap
|
||||
import android.net.Uri
|
||||
import android.provider.OpenableColumns
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateListOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* Files the user attaches to a message, copied into the Linux userland so the agent's own tools
|
||||
* can read them (Claude Code's Read shows images and PDFs to the model).
|
||||
*/
|
||||
object AgentAttachments {
|
||||
/** Guest paths waiting to go with the next message. */
|
||||
val pending = mutableStateListOf<String>()
|
||||
|
||||
private const val NEW = "new"
|
||||
private const val GUEST_DIR = "/root/.cache/droiddeck/attachments"
|
||||
private val IMAGE = setOf("png", "jpg", "jpeg", "webp", "gif", "bmp")
|
||||
|
||||
fun hostDir(context: Context) = File(LinuxRuntime.rootDir(context.applicationContext), GUEST_DIR.removePrefix("/"))
|
||||
|
||||
fun host(context: Context, guestPath: String) = File(LinuxRuntime.rootDir(context.applicationContext), guestPath.removePrefix("/"))
|
||||
|
||||
fun isImage(path: String) = path.substringAfterLast('.', "").lowercase() in IMAGE
|
||||
|
||||
/** Copies [uris] for [chat] (or a new conversation) on the calling thread; returns their guest paths. */
|
||||
fun copy(context: Context, chat: String?, uris: List<Uri>): List<String> {
|
||||
val app = context.applicationContext
|
||||
val folder = chat ?: NEW
|
||||
val dir = File(hostDir(app), folder).apply { mkdirs() }
|
||||
return uris.mapNotNull { uri ->
|
||||
runCatching {
|
||||
val name = displayName(app, uri).replace(Regex("[^A-Za-z0-9._-]"), "_").ifEmpty { "file" }
|
||||
var target = File(dir, name)
|
||||
var n = 1
|
||||
while (target.exists()) target = File(dir, "${name.substringBeforeLast('.')}-${n++}${name.substringAfterLast('.', "").let { if (it.isEmpty()) "" else ".$it" }}")
|
||||
app.contentResolver.openInputStream(uri)!!.use { input -> target.outputStream().use { input.copyTo(it) } }
|
||||
"$GUEST_DIR/$folder/${target.name}"
|
||||
}.getOrNull()
|
||||
}
|
||||
}
|
||||
|
||||
/** Moves files attached before [chat] existed into its folder, so deleting the chat removes them; returns their new guest paths. */
|
||||
fun adopt(context: Context, chat: String, files: List<String>): List<String> = files.map { path ->
|
||||
if (!path.startsWith("$GUEST_DIR/$NEW/")) return@map path
|
||||
val dir = File(hostDir(context), chat).apply { mkdirs() }
|
||||
val moved = File(dir, path.substringAfterLast('/'))
|
||||
if (host(context, path).renameTo(moved)) "$GUEST_DIR/$chat/${moved.name}" else path
|
||||
}
|
||||
|
||||
/** Copies the running game's frame; set while a session is open. */
|
||||
var gameFrame by mutableStateOf<(((Bitmap?) -> Unit) -> Unit)?>(null)
|
||||
|
||||
/** Saves [frame] for [chat] (or a new conversation) on the calling thread; returns its guest path. */
|
||||
fun saveFrame(context: Context, chat: String?, frame: Bitmap): String? = runCatching {
|
||||
val folder = chat ?: NEW
|
||||
val dir = File(hostDir(context), folder).apply { mkdirs() }
|
||||
val target = File(dir, "game-${System.currentTimeMillis()}.jpg")
|
||||
val written = target.outputStream().use { frame.compress(Bitmap.CompressFormat.JPEG, 88, it) }
|
||||
if (!written) {
|
||||
target.delete()
|
||||
return@runCatching null
|
||||
}
|
||||
"$GUEST_DIR/$folder/${target.name}"
|
||||
}.getOrNull()
|
||||
|
||||
/** Deletes copies that will not be sent. */
|
||||
fun discard(context: Context, files: List<String>) = files.forEach { host(context, it).delete() }
|
||||
|
||||
/** The message the CLI gets: the user's text, then where the attached files are. */
|
||||
fun prompt(text: String, files: List<String>): String {
|
||||
if (files.isEmpty()) return text
|
||||
val list = files.joinToString("\n") { "- $it" }
|
||||
return "$text\n\nAttached files (read them with your tools):\n$list".trim()
|
||||
}
|
||||
|
||||
private fun displayName(context: Context, uri: Uri): String =
|
||||
context.contentResolver.query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)?.use { c ->
|
||||
if (c.moveToFirst()) c.getString(0) else null
|
||||
} ?: uri.lastPathSegment?.substringAfterLast('/') ?: "file"
|
||||
}
|
||||
@@ -85,6 +85,10 @@ class AgentBridgeProvider : ContentProvider() {
|
||||
AgentAccess.requireCommands(context)
|
||||
guest(context, JSONObject(request.toString()).put("kind", "exec"), timeoutMs(request, 30.0, 10_000))
|
||||
}
|
||||
"native" -> {
|
||||
AgentAccess.requireCommands(context)
|
||||
AgentNative.run(context, request, timeoutMs(request, 30.0, 0))
|
||||
}
|
||||
"cdp" -> {
|
||||
AgentAccess.requireCommands(context)
|
||||
guest(context, JSONObject(request.toString()).put("kind", "cdp"), timeoutMs(request, 15.0, 5_000))
|
||||
@@ -284,6 +288,8 @@ class AgentBridgeProvider : ContentProvider() {
|
||||
return JSONObject()
|
||||
.put("schema", SCHEMA)
|
||||
.put("build", BuildConfig.BUILD_LABEL)
|
||||
.put("apkCommit", com.droiddeck.launcher.lab.LabOverlay.apkCommit)
|
||||
.put("lab", com.droiddeck.launcher.lab.LabOverlay.active?.label ?: JSONObject.NULL)
|
||||
.put("appVersion", context.packageManager.getPackageInfo(context.packageName, 0).versionName)
|
||||
.put("runtime", JSONObject()
|
||||
.put("installed", LinuxRuntime.isInstalled(context))
|
||||
|
||||
@@ -4,6 +4,7 @@ import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.os.Bundle
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
@@ -17,9 +18,17 @@ class AgentCallReceiver : BroadcastReceiver() {
|
||||
val id = intent.getStringExtra("id")?.takeIf { it.matches(Regex("[A-Za-z0-9_-]{1,64}")) } ?: return
|
||||
val arg = intent.getStringExtra("arg")
|
||||
val request = intent.getStringExtra(AgentBridgeProvider.EXTRA_REQUEST)
|
||||
val pending = goAsync()
|
||||
Thread({
|
||||
val json = try {
|
||||
val app = context.applicationContext
|
||||
// The caller waits for the answer file, not for the broadcast. Holding the broadcast open
|
||||
// with goAsync() for a call that outlasts the broadcast timeout (10 s in the foreground)
|
||||
// makes Android report the app as not responding.
|
||||
Thread({ answer(app, method, id, call(app, method, arg, request)) }, "agent-call-$id").start()
|
||||
}
|
||||
|
||||
companion object {
|
||||
@VisibleForTesting
|
||||
internal var call: (Context, String, String?, String?) -> String = { context, method, arg, request ->
|
||||
try {
|
||||
val extras = Bundle().apply { putString(AgentBridgeProvider.EXTRA_REQUEST, request) }
|
||||
context.contentResolver.call("${context.packageName}.agent", method, arg, extras)
|
||||
?.getString(AgentBridgeProvider.RESULT_JSON) ?: """{"ok":false,"error":{"code":"NO_RESPONSE","message":"no response"}}"""
|
||||
@@ -27,15 +36,16 @@ class AgentCallReceiver : BroadcastReceiver() {
|
||||
org.json.JSONObject().put("ok", false)
|
||||
.put("error", org.json.JSONObject().put("code", "COMMAND_FAILED").put("message", e.message ?: e.javaClass.simpleName)).toString()
|
||||
}
|
||||
}
|
||||
|
||||
private fun answer(context: Context, method: String, id: String, json: String) {
|
||||
try {
|
||||
val dir = File(context.getExternalFilesDir(null), "agent-calls").apply { mkdirs() }
|
||||
File(dir, "$id.json.part").writeText(json)
|
||||
File(dir, "$id.json.part").renameTo(File(dir, "$id.json"))
|
||||
} catch (e: Exception) {
|
||||
android.util.Log.w("AgentCallReceiver", "could not write the answer to $method: ${e.message}")
|
||||
} finally {
|
||||
pending.finish()
|
||||
}
|
||||
}, "agent-call-$id").start()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import com.droiddeck.launcher.agent.AgentHost.Entry
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* Conversations kept on the device, one JSON Lines file each in `files/agent/chats`: a header
|
||||
* line with the harness, a line with the CLI's conversation id once it has one, then the entries.
|
||||
*/
|
||||
object AgentChats {
|
||||
data class Chat(val id: String, val harness: String, val title: String, val updated: Long)
|
||||
|
||||
class Loaded(val harness: String?, val conversation: String?, val entries: List<Entry>)
|
||||
|
||||
private const val MAX_OUTPUT = 24_000
|
||||
|
||||
fun dir(context: Context) = File(context.filesDir, "agent/chats")
|
||||
|
||||
fun file(context: Context, id: String) = File(dir(context), "$id.jsonl")
|
||||
|
||||
fun newId(context: Context): String {
|
||||
var stamp = System.currentTimeMillis()
|
||||
while (file(context, stamp.toString()).exists()) stamp++
|
||||
return stamp.toString()
|
||||
}
|
||||
|
||||
/** Newest first; chats with nothing asked yet are left out. */
|
||||
fun list(context: Context): List<Chat> = dir(context).listFiles { f -> f.name.endsWith(".jsonl") }.orEmpty()
|
||||
.mapNotNull { f ->
|
||||
val loaded = read(f)
|
||||
val title = loaded.entries.firstNotNullOfOrNull { (it as? Entry.Asked)?.text } ?: return@mapNotNull null
|
||||
Chat(f.name.removeSuffix(".jsonl"), loaded.harness ?: ClaudeCode.id, title.lineSequence().first().take(120), f.lastModified())
|
||||
}
|
||||
.sortedByDescending { it.updated }
|
||||
|
||||
/** The chats among [chats] where the user or the agent wrote [query], ignoring case. */
|
||||
fun search(context: Context, chats: List<Chat>, query: String): List<Chat> {
|
||||
val q = query.trim()
|
||||
if (q.isEmpty()) return chats
|
||||
return chats.filter { chat ->
|
||||
chat.title.contains(q, ignoreCase = true) || read(file(context, chat.id)).entries.any { matches(it, q) }
|
||||
}
|
||||
}
|
||||
|
||||
internal fun matches(entry: Entry, query: String) = when (entry) {
|
||||
is Entry.Asked -> entry.text.contains(query, ignoreCase = true)
|
||||
is Entry.Said -> entry.text.contains(query, ignoreCase = true)
|
||||
else -> false
|
||||
}
|
||||
|
||||
fun delete(context: Context, id: String) {
|
||||
file(context, id).delete()
|
||||
File(AgentAttachments.hostDir(context), id).deleteRecursively()
|
||||
}
|
||||
|
||||
fun start(file: File, harness: String) {
|
||||
file.parentFile?.mkdirs()
|
||||
file.writeText(JSONObject().put("harness", harness).toString() + "\n")
|
||||
}
|
||||
|
||||
fun appendConversation(file: File, conversation: String) =
|
||||
runCatching { file.appendText(JSONObject().put("conversation", conversation).toString() + "\n") }
|
||||
|
||||
fun append(file: File, entry: Entry) = runCatching { file.appendText(encode(entry) + "\n") }
|
||||
|
||||
/** The transcript before chats were kept, moved into the first chat. */
|
||||
fun migrate(context: Context, harness: String, conversation: String?): String? {
|
||||
val old = File(context.filesDir, "agent/transcript.jsonl")
|
||||
if (!old.isFile) return null
|
||||
val id = newId(context)
|
||||
val target = file(context, id)
|
||||
start(target, harness)
|
||||
conversation?.let { appendConversation(target, it) }
|
||||
target.appendText(old.readText())
|
||||
old.delete()
|
||||
return id
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun encode(entry: Entry): String = when (entry) {
|
||||
is Entry.Asked -> JSONObject().put("asked", entry.text).apply { if (entry.files.isNotEmpty()) put("files", JSONArray(entry.files)) }
|
||||
is Entry.Said -> JSONObject().put("said", entry.text)
|
||||
is Entry.Notice -> JSONObject().put("notice", entry.text)
|
||||
is Entry.Thought -> JSONObject().put("thought", entry.text)
|
||||
is Entry.Result -> JSONObject().put("result", entry.id).put("output", entry.output).put("failed", entry.failed)
|
||||
is Entry.Used -> JSONObject().put("used", entry.tool).put("detail", entry.detail).put("id", entry.id).put("input", entry.input)
|
||||
.apply { if (entry.parent.isNotEmpty()) put("parent", entry.parent) }
|
||||
.apply { entry.output?.let { put("output", it).put("failed", entry.failed) } }
|
||||
is Entry.Finished -> JSONObject().put("finished", true).put("error", entry.error ?: JSONObject.NULL).put("stopped", entry.stopped).apply {
|
||||
if (entry.planned) put("planned", true)
|
||||
entry.usage?.let {
|
||||
put("ms", it.durationMs).put("cost", it.costUsd).put("in", it.inputTokens).put("out", it.outputTokens)
|
||||
if (it.context > 0) put("ctx", it.context).put("win", it.window)
|
||||
}
|
||||
}
|
||||
}.toString()
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun read(file: File): Loaded {
|
||||
var harness: String? = null
|
||||
var conversation: String? = null
|
||||
val entries = mutableListOf<Entry>()
|
||||
runCatching {
|
||||
file.forEachLine { line ->
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return@forEachLine
|
||||
when {
|
||||
o.has("harness") -> harness = o.getString("harness")
|
||||
o.has("conversation") -> conversation = o.getString("conversation")
|
||||
else -> decode(o)?.let { merge(entries, it) }
|
||||
}
|
||||
}
|
||||
}
|
||||
return Loaded(harness, conversation, entries)
|
||||
}
|
||||
|
||||
private fun decode(o: JSONObject): Entry? = when {
|
||||
o.has("asked") -> Entry.Asked(o.getString("asked"), o.optJSONArray("files")?.let { a -> (0 until a.length()).map { a.getString(it) } }.orEmpty())
|
||||
o.has("said") -> Entry.Said(o.getString("said"))
|
||||
o.has("notice") -> Entry.Notice(o.getString("notice"))
|
||||
o.has("thought") -> Entry.Thought(o.getString("thought"))
|
||||
o.has("used") -> Entry.Used(o.optString("id"), o.getString("used"), o.optString("detail"), o.optString("input"),
|
||||
if (o.has("output")) o.optString("output") else null, o.optBoolean("failed"), o.optString("parent"))
|
||||
o.has("result") -> Entry.Result(o.getString("result"), o.optString("output"), o.optBoolean("failed"))
|
||||
o.has("finished") -> Entry.Finished(
|
||||
if (o.isNull("error")) null else o.optString("error"), o.optBoolean("stopped"),
|
||||
if (o.has("ms")) AgentHost.Usage(o.optLong("ms"), o.optDouble("cost", 0.0), o.optLong("in"), o.optLong("out"), o.optLong("ctx"), o.optLong("win")) else null,
|
||||
o.optBoolean("planned"),
|
||||
)
|
||||
else -> null
|
||||
}
|
||||
|
||||
/**
|
||||
* A tool's result is shown on the call it answers, and a call seen again (an updated todo list)
|
||||
* replaces it. Only the current turn is searched: Codex numbers its items again in each process.
|
||||
*/
|
||||
fun merge(entries: MutableList<Entry>, entry: Entry): Boolean {
|
||||
val turn = entries.indexOfLast { it is Entry.Asked }
|
||||
if (entry is Entry.Used && entry.id.isNotEmpty()) {
|
||||
val same = entries.indexOfLast { it is Entry.Used && it.id == entry.id }
|
||||
if (same > turn) {
|
||||
entries[same] = entry
|
||||
return true
|
||||
}
|
||||
}
|
||||
if (entry !is Entry.Result) {
|
||||
entries += entry
|
||||
return true
|
||||
}
|
||||
val index = entries.indexOfLast { it is Entry.Used && it.id == entry.id && entry.id.isNotEmpty() }
|
||||
if (index <= turn) return false
|
||||
entries[index] = (entries[index] as Entry.Used).copy(output = clip(entry.output), failed = entry.failed)
|
||||
return true
|
||||
}
|
||||
|
||||
/** Long outputs keep their end, where errors and summaries usually are. */
|
||||
fun clip(output: String) = if (output.length <= MAX_OUTPUT) output else "…\n" + output.takeLast(MAX_OUTPUT)
|
||||
}
|
||||
@@ -0,0 +1,416 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
|
||||
/** One coding agent CLI in the Linux userland, run one process per turn (or kept open, see [input]). */
|
||||
interface AgentHarness {
|
||||
val id: String
|
||||
val name: String
|
||||
/** Absolute guest path of the CLI. */
|
||||
val binary: String
|
||||
/** Guest paths of everything the CLI needs installed, [binary] included. */
|
||||
val files: List<String> get() = listOf(binary)
|
||||
/** A guest shell script that installs the CLI. */
|
||||
val install: String
|
||||
/** A guest command whose exit status is 0 when the CLI is signed in. */
|
||||
val signedIn: List<String>
|
||||
/** A guest command that signs in through $BROWSER. */
|
||||
val signIn: List<String>
|
||||
/** Whether [Options.plan] means anything to this CLI. */
|
||||
val plans: Boolean
|
||||
/** Reasoning effort levels the CLI accepts, lowest first; empty when it has none. */
|
||||
val efforts: List<String>
|
||||
/** Models to offer besides the CLI's default; [rootfs] is where the CLI's own files can be read. */
|
||||
fun models(rootfs: File): List<Model>
|
||||
/** The guest command for one turn; [conversation] is null for the first one. */
|
||||
fun turn(message: String, conversation: String?, options: Options): List<String>
|
||||
/**
|
||||
* The line that hands [message] to a [turn] process over stdin, or null when the message is already in the
|
||||
* command. A process that takes its messages this way stays open between turns, so work it started in the
|
||||
* background can wake it, as it does in the CLI's own terminal.
|
||||
*/
|
||||
fun input(message: String): String? = null
|
||||
/** One line of the CLI's output, or null when it carries nothing to show. */
|
||||
fun parse(line: String): AgentEvent?
|
||||
/** Sets the CLI's own defaults in the userland before it runs; [rootfs] is the userland's root. */
|
||||
fun prepare(rootfs: File) {}
|
||||
/** Context and plan limits the CLI keeps on disk rather than printing, read once a turn of [conversation] is done. */
|
||||
fun usage(rootfs: File, conversation: String?): AgentEvent? = null
|
||||
|
||||
data class Model(val id: String, val label: String)
|
||||
|
||||
data class Options(val model: String? = null, val plan: Boolean = false, val brief: String? = null, val effort: String? = null)
|
||||
|
||||
companion object {
|
||||
val all: List<AgentHarness> = listOf(ClaudeCode, Codex)
|
||||
fun byId(id: String?): AgentHarness = all.firstOrNull { it.id == id } ?: ClaudeCode
|
||||
}
|
||||
}
|
||||
|
||||
/** What one line of output carries: whole entries, or text still being written. */
|
||||
data class AgentEvent(
|
||||
val conversation: String? = null,
|
||||
val entries: List<AgentHost.Entry> = emptyList(),
|
||||
val text: String? = null,
|
||||
val thinking: String? = null,
|
||||
/** Tokens the conversation's context holds after this step. */
|
||||
val context: Long? = null,
|
||||
/** Tokens the model's context can hold. */
|
||||
val window: Long? = null,
|
||||
val limits: List<AgentHost.Limit>? = null,
|
||||
val usage: AgentHost.Usage? = null,
|
||||
/** This ends a turn the CLI started itself, such as the answer to a finished background task. */
|
||||
val background: Boolean = false,
|
||||
/** The error a background turn ended with, if it failed. */
|
||||
val backgroundError: String? = null,
|
||||
)
|
||||
|
||||
/** Claude Code: `claude -p` with stream-json input and output, resumed by session id. */
|
||||
object ClaudeCode : AgentHarness {
|
||||
override val id = "claude"
|
||||
override val name = "Claude Code"
|
||||
override val binary = "/root/.local/bin/claude"
|
||||
override val install = "curl -fsSL https://claude.ai/install.sh | bash"
|
||||
override val signedIn = listOf("sh", "-c", "$binary auth status | grep -q '\"loggedIn\": true'")
|
||||
override val signIn = listOf(binary, "auth", "login", "--claudeai")
|
||||
override val plans = true
|
||||
override val efforts = listOf("low", "medium", "high", "xhigh", "max")
|
||||
|
||||
/**
|
||||
* Commits and pull requests the agent makes carry no Claude Code credit or co-author line by
|
||||
* default. Only keys the user has not set are written, so their own choice stays.
|
||||
*/
|
||||
override fun prepare(rootfs: File) {
|
||||
val file = File(rootfs, "root/.claude/settings.json")
|
||||
val settings = if (file.exists()) runCatching { JSONObject(file.readText()) }.getOrNull() ?: return else JSONObject()
|
||||
var changed = false
|
||||
if (!settings.has("includeCoAuthoredBy")) {
|
||||
settings.put("includeCoAuthoredBy", false)
|
||||
changed = true
|
||||
}
|
||||
if (!settings.has("attribution")) {
|
||||
settings.put("attribution", JSONObject().put("commit", "").put("pr", ""))
|
||||
changed = true
|
||||
}
|
||||
if (changed) runCatching {
|
||||
file.parentFile?.mkdirs()
|
||||
file.writeText(settings.toString(2) + "\n")
|
||||
}
|
||||
}
|
||||
|
||||
override fun models(rootfs: File) = listOf(
|
||||
AgentHarness.Model("opus", "Opus"), AgentHarness.Model("sonnet", "Sonnet"), AgentHarness.Model("haiku", "Haiku"),
|
||||
)
|
||||
|
||||
// DroidDeck runs the agent unattended on the user's own device; permission prompts have no one to answer them.
|
||||
override fun turn(message: String, conversation: String?, options: AgentHarness.Options) = buildList {
|
||||
addAll(listOf(binary, "-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose", "--include-partial-messages"))
|
||||
addAll(listOf("--permission-mode", if (options.plan) "plan" else "bypassPermissions"))
|
||||
options.model?.let { addAll(listOf("--model", it)) }
|
||||
options.effort?.let { addAll(listOf("--effort", it)) }
|
||||
options.brief?.let { addAll(listOf("--append-system-prompt", it)) }
|
||||
if (conversation != null) addAll(listOf("--resume", conversation))
|
||||
}
|
||||
|
||||
override fun input(message: String): String? = JSONObject()
|
||||
.put("type", "user")
|
||||
.put("message", JSONObject().put("role", "user").put("content", JSONArray().put(JSONObject().put("type", "text").put("text", message))))
|
||||
.toString()
|
||||
|
||||
override fun parse(line: String): AgentEvent? {
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
|
||||
val conversation = o.optString("session_id").takeIf { it.isNotEmpty() }
|
||||
// A subagent's messages carry the call that started it; only its tool calls are shown, under that call.
|
||||
val parent = o.optString("parent_tool_use_id").takeIf { it.isNotEmpty() && it != "null" }
|
||||
return when (o.optString("type")) {
|
||||
"stream_event" -> {
|
||||
if (parent != null) return null
|
||||
val delta = o.optJSONObject("event")?.takeIf { it.optString("type") == "content_block_delta" }?.optJSONObject("delta") ?: return null
|
||||
when (delta.optString("type")) {
|
||||
"text_delta" -> AgentEvent(conversation, text = delta.optString("text"))
|
||||
"thinking_delta" -> AgentEvent(conversation, thinking = delta.optString("thinking"))
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
"assistant" -> {
|
||||
val message = o.optJSONObject("message")
|
||||
val content = message?.optJSONArray("content") ?: JSONArray()
|
||||
val entries = (0 until content.length()).mapNotNull { i ->
|
||||
val block = content.optJSONObject(i) ?: return@mapNotNull null
|
||||
when (block.optString("type")) {
|
||||
"text" -> if (parent != null) null else block.optString("text").trim().takeIf { it.isNotEmpty() }?.let { AgentHost.Entry.Said(it) }
|
||||
"thinking" -> if (parent != null) null else block.optString("thinking").trim().takeIf { it.isNotEmpty() }?.let { AgentHost.Entry.Thought(it) }
|
||||
"tool_use" -> {
|
||||
val input = block.optJSONObject("input")
|
||||
AgentHost.Entry.Used(
|
||||
block.optString("id"), block.optString("name"), detail(input), fullInput(block.optString("name"), input),
|
||||
parent = parent.orEmpty(),
|
||||
background = input?.optBoolean("run_in_background") == true || block.optString("name") == "Monitor",
|
||||
)
|
||||
}
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
val usage = message?.optJSONObject("usage")
|
||||
val context = usage?.let { it.optLong("input_tokens") + it.optLong("cache_read_input_tokens") + it.optLong("cache_creation_input_tokens") + it.optLong("output_tokens") }
|
||||
AgentEvent(conversation, entries, context = context?.takeIf { it > 0 && parent == null })
|
||||
}
|
||||
"user" -> {
|
||||
val content = o.optJSONObject("message")?.optJSONArray("content") ?: return conversation?.let { AgentEvent(it) }
|
||||
val results = (0 until content.length()).mapNotNull { i ->
|
||||
val block = content.optJSONObject(i)?.takeIf { it.optString("type") == "tool_result" } ?: return@mapNotNull null
|
||||
AgentHost.Entry.Result(block.optString("tool_use_id"), resultText(block.opt("content")), block.optBoolean("is_error"))
|
||||
}
|
||||
AgentEvent(conversation, results)
|
||||
}
|
||||
"rate_limit_event" -> AgentEvent(conversation, limits = limits(o.optJSONObject("rate_limit_info")))
|
||||
// The CLI starts turns of its own for background tasks (a resumed session first answers the ones the last
|
||||
// run left behind). Such a result is not the end of the user's turn; the host decides what it ends.
|
||||
"result" -> {
|
||||
val usage = AgentHost.Usage(
|
||||
o.optLong("duration_ms"), o.optDouble("total_cost_usd", 0.0),
|
||||
o.optJSONObject("usage")?.let { it.optLong("input_tokens") + it.optLong("cache_read_input_tokens") + it.optLong("cache_creation_input_tokens") } ?: 0,
|
||||
o.optJSONObject("usage")?.optLong("output_tokens") ?: 0,
|
||||
)
|
||||
if (o.optJSONObject("origin")?.optString("kind") == "task-notification") AgentEvent(
|
||||
conversation, usage = usage, background = true,
|
||||
backgroundError = if (o.optBoolean("is_error")) o.optString("result").ifEmpty { o.optString("subtype") } else null,
|
||||
)
|
||||
else AgentEvent(
|
||||
conversation,
|
||||
listOf(AgentHost.Entry.Finished(if (o.optBoolean("is_error")) o.optString("result").ifEmpty { o.optString("subtype") } else null)),
|
||||
window = window(o.optJSONObject("modelUsage")),
|
||||
usage = usage,
|
||||
)
|
||||
}
|
||||
else -> conversation?.let { AgentEvent(it) }
|
||||
}
|
||||
}
|
||||
|
||||
private val WINDOW_MINUTES = mapOf("five_hour" to 300, "seven_day" to 10_080)
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun limits(info: JSONObject?): List<AgentHost.Limit>? {
|
||||
val windows = info?.optJSONObject("unifiedWindows") ?: return null
|
||||
return WINDOW_MINUTES.mapNotNull { (key, minutes) ->
|
||||
val w = windows.optJSONObject(key) ?: return@mapNotNull null
|
||||
AgentHost.Limit(minutes, (w.optDouble("utilization", 0.0) * 100).toInt(), w.optLong("resetsAt"))
|
||||
}.takeIf { it.isNotEmpty() }
|
||||
}
|
||||
|
||||
/** The context window of the model that did most of the turn; subagents may run a smaller one. */
|
||||
private fun window(models: JSONObject?): Long? {
|
||||
models ?: return null
|
||||
return models.keys().asSequence().mapNotNull { models.optJSONObject(it) }
|
||||
.maxByOrNull { it.optDouble("costUSD", 0.0) }?.optLong("contextWindow")?.takeIf { it > 0 }
|
||||
}
|
||||
|
||||
private fun resultText(content: Any?): String = when (content) {
|
||||
is String -> content
|
||||
is JSONArray -> (0 until content.length()).mapNotNull { i ->
|
||||
val part = content.optJSONObject(i) ?: return@mapNotNull null
|
||||
when (part.optString("type")) {
|
||||
"text" -> part.optString("text")
|
||||
"image" -> "[image]"
|
||||
else -> null
|
||||
}
|
||||
}.joinToString("\n")
|
||||
null, JSONObject.NULL -> ""
|
||||
else -> content.toString()
|
||||
}
|
||||
|
||||
private fun detail(input: JSONObject?): String {
|
||||
input ?: return ""
|
||||
for (key in listOf("command", "file_path", "pattern", "url", "query", "description", "prompt")) {
|
||||
input.optString(key).takeIf { it.isNotEmpty() }?.let { return firstLine(it) }
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun fullInput(tool: String, input: JSONObject?): String {
|
||||
input ?: return ""
|
||||
return when {
|
||||
tool == "Bash" -> input.optString("command")
|
||||
tool == "Edit" -> input.optString("file_path") + "\n" + lineDiff(input.optString("old_string"), input.optString("new_string"))
|
||||
tool == "Write" -> input.optString("file_path") + "\n" + lineDiff("", input.optString("content"))
|
||||
tool == "TodoWrite" -> todos(input.optJSONArray("todos"))
|
||||
else -> input.toString(2)
|
||||
}
|
||||
}
|
||||
|
||||
private fun todos(list: JSONArray?) = (0 until (list?.length() ?: 0)).mapNotNull { i ->
|
||||
val todo = list?.optJSONObject(i) ?: return@mapNotNull null
|
||||
val mark = when (todo.optString("status")) { "completed" -> "[x]"; "in_progress" -> "[~]"; else -> "[ ]" }
|
||||
"$mark ${todo.optString("content")}"
|
||||
}.joinToString("\n")
|
||||
}
|
||||
|
||||
/** OpenAI Codex: `codex exec --json`, resumed by thread id. */
|
||||
object Codex : AgentHarness {
|
||||
override val id = "codex"
|
||||
override val name = "Codex"
|
||||
override val binary = "/root/.local/bin/codex"
|
||||
// Code mode runs in a helper that each release ships as its own download.
|
||||
private const val HOST = "/root/.local/bin/codex-code-mode-host"
|
||||
override val files get() = listOf(binary, HOST)
|
||||
override val install = """
|
||||
set -e
|
||||
release=${'$'}(curl -fsSL https://api.github.com/repos/openai/codex/releases/latest)
|
||||
mkdir -p /root/.local/bin
|
||||
for name in codex codex-code-mode-host; do
|
||||
url=${'$'}(printf '%s' "${'$'}release" | grep -o "https://[^\"]*/${'$'}name-aarch64-unknown-linux-musl.tar.gz" | head -1)
|
||||
echo "Downloading ${'$'}name"
|
||||
curl -fsSL "${'$'}url" | tar -xz -C /tmp
|
||||
install -m755 /tmp/${'$'}name-aarch64-unknown-linux-musl /root/.local/bin/${'$'}name
|
||||
done
|
||||
""".trimIndent()
|
||||
override val signedIn = listOf(binary, "login", "status")
|
||||
override val signIn = listOf(binary, "login")
|
||||
override val plans = false
|
||||
override val efforts = listOf("low", "medium", "high")
|
||||
|
||||
/** Codex keeps the models its account can use in `~/.codex/models_cache.json` once it has run. */
|
||||
override fun models(rootfs: File): List<AgentHarness.Model> = runCatching {
|
||||
val o = JSONObject(File(rootfs, "root/.codex/models_cache.json").readText())
|
||||
val list = o.optJSONArray("models") ?: JSONArray()
|
||||
(0 until list.length()).mapNotNull { i ->
|
||||
val m = list.optJSONObject(i) ?: return@mapNotNull null
|
||||
val slug = m.optString("slug").ifEmpty { m.optString("id") }.takeIf { it.isNotEmpty() } ?: return@mapNotNull null
|
||||
if (m.has("visibility") && m.optString("visibility") != "list") return@mapNotNull null
|
||||
AgentHarness.Model(slug, m.optString("display_name").ifEmpty { slug })
|
||||
}
|
||||
}.getOrDefault(emptyList())
|
||||
|
||||
// Codex's own sandbox needs Landlock and seccomp, which proot does not provide.
|
||||
override fun turn(message: String, conversation: String?, options: AgentHarness.Options) = buildList {
|
||||
addAll(listOf(binary, "exec"))
|
||||
if (conversation != null) addAll(listOf("resume", conversation))
|
||||
addAll(listOf("--json", "--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check"))
|
||||
options.model?.let { addAll(listOf("-m", it)) }
|
||||
options.effort?.let { addAll(listOf("-c", "model_reasoning_effort=\"$it\"")) }
|
||||
// codex exec has no system prompt option, so a new conversation starts with the brief.
|
||||
add(if (conversation == null && options.brief != null) "${options.brief}\n\n$message" else message)
|
||||
}
|
||||
|
||||
override fun parse(line: String): AgentEvent? {
|
||||
val o = runCatching { JSONObject(line) }.getOrNull() ?: return null
|
||||
val item = o.optJSONObject("item")
|
||||
val id = item?.optString("id").orEmpty()
|
||||
val entries = when (o.optString("type")) {
|
||||
"thread.started" -> return AgentEvent(o.optString("thread_id").takeIf { it.isNotEmpty() })
|
||||
"item.started" -> when (item?.optString("type")) {
|
||||
"command_execution" -> shellCommand(item.optString("command")).let { listOf(AgentHost.Entry.Used(id, "Shell", firstLine(it), it)) }
|
||||
"mcp_tool_call" -> listOf(AgentHost.Entry.Used(id, item.optString("tool").ifEmpty { "Tool" }, item.optString("server"), item.optJSONObject("arguments")?.toString(2).orEmpty()))
|
||||
"web_search" -> listOf(AgentHost.Entry.Used(id, "Search", item.optString("query"), item.optString("query")))
|
||||
else -> emptyList()
|
||||
}
|
||||
"item.updated" -> when (item?.optString("type")) {
|
||||
"todo_list" -> listOf(todoEntry(id, item))
|
||||
else -> emptyList()
|
||||
}
|
||||
"item.completed" -> when (item?.optString("type")) {
|
||||
"agent_message" -> item.optString("text").trim().takeIf { it.isNotEmpty() }?.let { listOf(AgentHost.Entry.Said(it)) }.orEmpty()
|
||||
"reasoning" -> item.optString("text").trim().takeIf { it.isNotEmpty() }?.let { listOf(AgentHost.Entry.Thought(it)) }.orEmpty()
|
||||
"command_execution" -> listOf(AgentHost.Entry.Result(id, item.optString("aggregated_output"),
|
||||
item.has("exit_code") && !item.isNull("exit_code") && item.optInt("exit_code") != 0))
|
||||
"mcp_tool_call" -> listOf(AgentHost.Entry.Result(id, item.optJSONObject("result")?.toString(2) ?: item.optJSONObject("error")?.optString("message").orEmpty(),
|
||||
item.optString("status") == "failed"))
|
||||
"web_search" -> listOf(AgentHost.Entry.Result(id, "", false))
|
||||
"file_change" -> listOf(
|
||||
AgentHost.Entry.Used(id, "Edit", changedFiles(item), changedFiles(item).replace(", ", "\n")),
|
||||
AgentHost.Entry.Result(id, item.optString("status"), item.optString("status") == "failed"),
|
||||
)
|
||||
"todo_list" -> listOf(todoEntry(id, item))
|
||||
"error" -> listOf(AgentHost.Entry.Said("⚠ " + item.optString("message")))
|
||||
else -> emptyList()
|
||||
}
|
||||
"turn.completed" -> return AgentEvent(
|
||||
entries = listOf(AgentHost.Entry.Finished(null)),
|
||||
usage = o.optJSONObject("usage")?.let { AgentHost.Usage(0, 0.0, it.optLong("input_tokens") + it.optLong("cached_input_tokens"), it.optLong("output_tokens")) },
|
||||
)
|
||||
"turn.failed" -> listOf(AgentHost.Entry.Finished(o.optJSONObject("error")?.optString("message") ?: "turn failed"))
|
||||
// codex reports a dropped stream it is retrying as an error event, and the turn goes on.
|
||||
"error" -> o.optString("message").let { message ->
|
||||
if (message.startsWith("Reconnecting...")) emptyList() else listOf(AgentHost.Entry.Finished(message.ifEmpty { "error" }))
|
||||
}
|
||||
else -> emptyList()
|
||||
}
|
||||
return if (entries.isEmpty()) null else AgentEvent(entries = entries)
|
||||
}
|
||||
|
||||
private const val TOKEN_COUNT = "\"payload\":{\"type\":\"token_count\""
|
||||
|
||||
/** Codex prints no limits with --json; its session log, named after the thread, has a token_count event each step. */
|
||||
override fun usage(rootfs: File, conversation: String?): AgentEvent? {
|
||||
conversation ?: return null
|
||||
val log = File(rootfs, "root/.codex/sessions").walkBottomUp().filter { it.isFile && it.name.endsWith("-$conversation.jsonl") }
|
||||
.maxByOrNull { it.lastModified() } ?: return null
|
||||
val last = runCatching { log.readLines().lastOrNull { it.contains(TOKEN_COUNT) } }.getOrNull() ?: return null
|
||||
return tokenCount(last)
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun tokenCount(line: String): AgentEvent? {
|
||||
val payload = runCatching { JSONObject(line).optJSONObject("payload") }.getOrNull()?.takeIf { it.optString("type") == "token_count" } ?: return null
|
||||
val info = payload.optJSONObject("info")
|
||||
val rates = payload.optJSONObject("rate_limits")
|
||||
val limits = listOf("primary", "secondary").mapNotNull { key ->
|
||||
val w = rates?.optJSONObject(key) ?: return@mapNotNull null
|
||||
AgentHost.Limit(w.optInt("window_minutes"), w.optDouble("used_percent", 0.0).toInt(), w.optLong("resets_at"))
|
||||
}
|
||||
return AgentEvent(
|
||||
context = info?.optJSONObject("last_token_usage")?.optLong("total_tokens")?.takeIf { it > 0 },
|
||||
window = info?.optLong("model_context_window")?.takeIf { it > 0 },
|
||||
limits = limits.takeIf { it.isNotEmpty() },
|
||||
)
|
||||
}
|
||||
|
||||
private fun todoEntry(id: String, item: JSONObject): AgentHost.Entry.Used {
|
||||
val items = item.optJSONArray("items") ?: JSONArray()
|
||||
val text = (0 until items.length()).mapNotNull { i ->
|
||||
val todo = items.optJSONObject(i) ?: return@mapNotNull null
|
||||
"${if (todo.optBoolean("completed")) "[x]" else "[ ]"} ${todo.optString("text")}"
|
||||
}.joinToString("\n")
|
||||
return AgentHost.Entry.Used("$id-todo", "TodoWrite", "", text, output = "")
|
||||
}
|
||||
|
||||
private fun changedFiles(item: JSONObject): String {
|
||||
val changes = item.optJSONArray("changes") ?: return ""
|
||||
return (0 until changes.length()).mapNotNull { changes.optJSONObject(it)?.optString("path") }.joinToString(", ").take(400)
|
||||
}
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun firstLine(text: String) = text.lineSequence().first().take(160)
|
||||
|
||||
private const val DIFF_CONTEXT = 2
|
||||
|
||||
/**
|
||||
* [old] against [new], one line per changed or nearby line, each led by ' ', '-' or '+'. Edits
|
||||
* replace a short span, so the lines both share at the start and end are cut to [DIFF_CONTEXT].
|
||||
*/
|
||||
@VisibleForTesting
|
||||
internal fun lineDiff(old: String, new: String): String {
|
||||
val a = if (old.isEmpty()) emptyList() else old.removeSuffix("\n").lines()
|
||||
val b = if (new.isEmpty()) emptyList() else new.removeSuffix("\n").lines()
|
||||
var head = 0
|
||||
while (head < a.size && head < b.size && a[head] == b[head]) head++
|
||||
var tail = 0
|
||||
while (tail < a.size - head && tail < b.size - head && a[a.size - 1 - tail] == b[b.size - 1 - tail]) tail++
|
||||
return buildList {
|
||||
a.subList(maxOf(0, head - DIFF_CONTEXT), head).forEach { add(" $it") }
|
||||
a.subList(head, a.size - tail).forEach { add("-$it") }
|
||||
b.subList(head, b.size - tail).forEach { add("+$it") }
|
||||
a.subList(a.size - tail, minOf(a.size, a.size - tail + DIFF_CONTEXT)).forEach { add(" $it") }
|
||||
}.joinToString("\n")
|
||||
}
|
||||
|
||||
private val SHELL_WRAPPER = Regex("^/bin/(?:ba)?sh -l?c '(.*)'$", RegexOption.DOT_MATCHES_ALL)
|
||||
|
||||
/** Codex runs each command as `/bin/bash -lc '<command>'`; the command is what the user wants to read. */
|
||||
@VisibleForTesting
|
||||
internal fun shellCommand(command: String) = SHELL_WRAPPER.find(command)?.groupValues?.get(1)?.replace("'\''", "'") ?: command
|
||||
@@ -0,0 +1,833 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import android.os.Environment
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.SystemClock
|
||||
import android.util.Log
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableLongStateOf
|
||||
import androidx.compose.runtime.mutableStateListOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import com.droiddeck.launcher.session.OrphanReaper
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
import java.io.File
|
||||
import java.nio.file.Files
|
||||
|
||||
/**
|
||||
* The launcher's agent: a coding agent CLI ([AgentHarness]) from the Linux userland, run headless
|
||||
* outside any game or desktop session: one process per turn, or for a CLI that takes its messages over
|
||||
* stdin one process kept open between turns, so background work can start a turn of its own. Conversations are kept on disk
|
||||
* ([AgentChats]), so a restart (a Lab build, a crash) continues the same one.
|
||||
*/
|
||||
object AgentHost {
|
||||
sealed interface Entry {
|
||||
data class Asked(val text: String, val files: List<String> = emptyList()) : Entry
|
||||
data class Said(val text: String) : Entry
|
||||
data class Notice(val text: String) : Entry
|
||||
data class Thought(val text: String) : Entry
|
||||
/**
|
||||
* A tool call; [output] stays null until its result arrives. [parent] is the subagent call it was made under, if any.
|
||||
* [background]: the call starts work that can wake the CLI after its turn (run_in_background, Monitor).
|
||||
*/
|
||||
data class Used(
|
||||
val id: String, val tool: String, val detail: String, val input: String = "", val output: String? = null, val failed: Boolean = false,
|
||||
val parent: String = "", val background: Boolean = false,
|
||||
) : Entry
|
||||
data class Result(val id: String, val output: String, val failed: Boolean) : Entry
|
||||
/** [planned]: the turn ran in plan mode, so it ends on a plan that nothing has carried out yet. */
|
||||
data class Finished(val error: String?, val stopped: Boolean = false, val usage: Usage? = null, val planned: Boolean = false) : Entry
|
||||
}
|
||||
|
||||
/** [context] of [window] tokens is what the conversation held when the turn ended. */
|
||||
data class Usage(
|
||||
val durationMs: Long, val costUsd: Double, val inputTokens: Long, val outputTokens: Long,
|
||||
val context: Long = 0, val window: Long = 0,
|
||||
)
|
||||
|
||||
/** A plan usage limit over a rolling window of [minutes]; [resetsAt] is in epoch seconds. */
|
||||
data class Limit(val minutes: Int, val usedPercent: Int, val resetsAt: Long)
|
||||
|
||||
/** A message typed while the agent was working, sent when the turn ends. */
|
||||
data class Queued(val text: String, val files: List<String>)
|
||||
|
||||
enum class State { MISSING, IDLE, WORKING }
|
||||
|
||||
private const val TAG = "AgentHost"
|
||||
private const val WORKSPACE = "/root/DroidDeck"
|
||||
internal const val GUEST_PATH = "/root/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
|
||||
private const val TICK_MS = 1_000L
|
||||
private const val IDLE_TICK_MS = 5_000L
|
||||
|
||||
/** Where the agent runs and what the user sees, which no file in the checkout tells it. */
|
||||
@VisibleForTesting
|
||||
internal const val BRIEF = "You run inside DroidDeck on the user's handheld, in its Linux userland (Ubuntu under proot, aarch64), " +
|
||||
"and the user talks to you from DroidDeck's Agent tab, often on a small screen, so keep replies short. " +
|
||||
"droiddeckctl inspects and drives the app over loopback adb (\$ADB_SERIAL); its guide is ${AgentSetup.CTL}/agent-control.md. " +
|
||||
"Steam, the desktop and games run in DroidDeck's session, a separate guest from yours: a program you start here is not in it and has no screen. " +
|
||||
"Reach the session through droiddeckctl: state, start steam, stop, launch, quit, focus, screenshot, logs, and guest to run a command inside it. " +
|
||||
"Starting, stopping or restarting a session leaves you running. " +
|
||||
"Never kill by a command-line pattern (pkill -f, pgrep -f piped to kill): your own command line holds the user's message, so the pattern matches you. " +
|
||||
"End a game with droiddeckctl quit, the session with droiddeckctl stop, anything else by its pid. " +
|
||||
"dd-lab-build builds the checkout as a Lab build and restarts DroidDeck on it (docs/lab-builds.md). DroidDeck runs the build in a " +
|
||||
"process of its own and shows the user its progress and time left; dd-lab-build follows that build's log until it is done. " +
|
||||
"Run it with run_in_background and keep checking its output, so the user can talk to you meanwhile. " +
|
||||
"The restart ends this process, and this conversation continues on the new build. " +
|
||||
"Files the user attaches are listed at the end of their message, under /root/.cache/droiddeck/attachments. " +
|
||||
"Commits and pull requests you make are the user's own: add no co-author line, AI credit or generated-by note. " +
|
||||
"To have the user pick between options, end your reply with a fenced code block whose language is choices, one short option per line, " +
|
||||
"and end your turn: DroidDeck shows them as buttons and sends the one picked as the next message."
|
||||
|
||||
val entries = mutableStateListOf<Entry>()
|
||||
val queue = mutableStateListOf<Queued>()
|
||||
var state by mutableStateOf(State.IDLE)
|
||||
private set
|
||||
var installed by mutableStateOf(false)
|
||||
private set
|
||||
/** The Linux runtime is there, so the agent can be set up. */
|
||||
var available by mutableStateOf(false)
|
||||
private set
|
||||
var harness by mutableStateOf<AgentHarness>(ClaudeCode)
|
||||
private set
|
||||
/** The chosen model for [harness]; null is the CLI's default. */
|
||||
var model by mutableStateOf<String?>(null)
|
||||
private set
|
||||
/** The chosen reasoning effort for [harness]; null is the CLI's default. */
|
||||
var effort by mutableStateOf<String?>(null)
|
||||
private set
|
||||
var plan by mutableStateOf(false)
|
||||
private set
|
||||
var chat by mutableStateOf<String?>(null)
|
||||
private set
|
||||
/** A reply finished since the conversation was last on screen. */
|
||||
var unseen by mutableStateOf(false)
|
||||
private set
|
||||
var failed by mutableStateOf(false)
|
||||
private set
|
||||
/** Text and thinking of the reply being written. */
|
||||
var live by mutableStateOf("")
|
||||
private set
|
||||
var liveThinking by mutableStateOf("")
|
||||
private set
|
||||
/** When the current turn started, on [SystemClock.elapsedRealtime]. */
|
||||
var turnStarted by mutableLongStateOf(0L)
|
||||
private set
|
||||
var now by mutableLongStateOf(0L)
|
||||
private set
|
||||
/** Tokens in the conversation's context after its last step. */
|
||||
var context by mutableLongStateOf(0L)
|
||||
private set
|
||||
/** Tokens the model's context can hold; 0 until a turn has told. */
|
||||
var window by mutableLongStateOf(0L)
|
||||
private set
|
||||
/** The account's plan limits as [harness] last reported them. */
|
||||
var limits by mutableStateOf<List<Limit>>(emptyList())
|
||||
private set
|
||||
var lab by mutableStateOf<LabProgress?>(null)
|
||||
private set
|
||||
|
||||
private class Turn(val process: Process, val pid: Int, val stdin: java.io.OutputStream? = null) {
|
||||
var writingGeneration: Int? = null
|
||||
var exitStatus: Int? = null
|
||||
var costs: AgentCostTracker? = null
|
||||
var clearingCosts = false
|
||||
}
|
||||
|
||||
private val main = Handler(Looper.getMainLooper())
|
||||
private var turn: Turn? = null
|
||||
/**
|
||||
* The CLI process when it takes its messages over stdin. It outlives a turn, so work it started in the
|
||||
* background can wake it: the answer to a finished task then arrives without a message from the user.
|
||||
*/
|
||||
private var session: Turn? = null
|
||||
private var sessionKey: String? = null
|
||||
/** The running turn is one the CLI started itself, not an answer to the user. */
|
||||
private var background = false
|
||||
private val reap = Runnable { if (state != State.WORKING) dropSession() }
|
||||
/** Counts turns, so a process that starts after its turn was stopped is not adopted by the next one. */
|
||||
private var generation = 0
|
||||
private var labProcess: Process? = null
|
||||
/** The turn now running resends a message that got no reply, so it is not resent again. */
|
||||
private var retrying = false
|
||||
private var resend: Runnable? = null
|
||||
/** The running Lab build was asked for by the current turn, so stopping the turn stops it. */
|
||||
private var labFromTurn = false
|
||||
private var conversation: String? = null
|
||||
private var turnPlanned = false
|
||||
private var loaded = false
|
||||
private var appContext: Context? = null
|
||||
/** A tool call in this CLI process started work that can wake it after its turn (run_in_background). */
|
||||
private var launchedBackground = false
|
||||
|
||||
val turnPid: Int get() = turn?.pid ?: 0
|
||||
|
||||
fun seen() {
|
||||
unseen = false
|
||||
appContext?.let { AgentNotice.clear(it) }
|
||||
}
|
||||
|
||||
fun refresh(context: Context) {
|
||||
val app = context.applicationContext
|
||||
appContext = app
|
||||
File(app.filesDir, "agent").mkdirs()
|
||||
harness = AgentHarness.byId(prefs(app).getString(HARNESS_KEY, null))
|
||||
model = prefs(app).getString(modelKey(harness), null)
|
||||
effort = prefs(app).getString(effortKey(harness), null)?.takeIf { it in harness.efforts }
|
||||
plan = prefs(app).getBoolean(PLAN_KEY, false)
|
||||
limits = decodeLimits(prefs(app).getString(limitsKey(harness), null))
|
||||
available = LinuxRuntime.hasRootfs(app)
|
||||
installed = harness.files.all { guestFileExists(app, it) }
|
||||
if (!installed) state = State.MISSING else if (state == State.MISSING) state = State.IDLE
|
||||
if (!loaded) {
|
||||
loaded = true
|
||||
val migrated = AgentChats.migrate(app, harness.id, prefs(app).getString(LEGACY_CONVERSATION_KEY, null))
|
||||
if (migrated != null) prefs(app).edit().remove(LEGACY_CONVERSATION_KEY).putString(CHAT_KEY, migrated).apply()
|
||||
prefs(app).getString(CHAT_KEY, null)?.let { load(app, it) }
|
||||
resumeAfterRestart(app)
|
||||
tick()
|
||||
}
|
||||
}
|
||||
|
||||
private fun load(app: Context, id: String) {
|
||||
val file = AgentChats.file(app, id)
|
||||
if (!file.isFile) return
|
||||
val loaded = AgentChats.read(file)
|
||||
if (chat != id) AgentAttachments.pending.clear()
|
||||
chat = id
|
||||
conversation = loaded.conversation
|
||||
entries.clear()
|
||||
entries.addAll(loaded.entries)
|
||||
val last = loaded.entries.lastOrNull { it is Entry.Finished && (it.usage?.context ?: 0) > 0 } as? Entry.Finished
|
||||
context = last?.usage?.context ?: 0
|
||||
window = last?.usage?.window ?: 0
|
||||
}
|
||||
|
||||
/** Opens a kept conversation, switching to the CLI it belongs to. */
|
||||
fun open(context: Context, id: String) {
|
||||
val app = context.applicationContext
|
||||
if (state == State.WORKING || id == chat) return
|
||||
val harnessId = AgentChats.read(AgentChats.file(app, id)).harness
|
||||
if (harnessId != null && harnessId != harness.id) {
|
||||
if (AgentSetup.busy) return
|
||||
prefs(app).edit().putString(HARNESS_KEY, harnessId).apply()
|
||||
AgentSetup.forget()
|
||||
refresh(app)
|
||||
}
|
||||
dropSession()
|
||||
load(app, id)
|
||||
prefs(app).edit().putString(CHAT_KEY, id).apply()
|
||||
}
|
||||
|
||||
fun delete(context: Context, id: String) {
|
||||
if (id == chat) {
|
||||
if (state == State.WORKING) return
|
||||
forget(context)
|
||||
}
|
||||
AgentChats.delete(context.applicationContext, id)
|
||||
}
|
||||
|
||||
/**
|
||||
* A Lab build restarts the app, which ends the agent's process mid-turn. dd-lab-build leaves
|
||||
* [RESUME] when the app's own agent ran it, so the same conversation picks up on the new build.
|
||||
*/
|
||||
private fun resumeAfterRestart(app: Context) {
|
||||
val marker = File(app.filesDir, RESUME)
|
||||
val claimed = File(app.filesDir, "$RESUME.claimed")
|
||||
if (!marker.renameTo(claimed)) return
|
||||
claimed.delete()
|
||||
val asked = prefs(app).getString(LAB_CHAT_KEY, null)
|
||||
prefs(app).edit().remove(LAB_CHAT_KEY).apply()
|
||||
if (!installed) return
|
||||
// The conversation that asked for the build hears about it, even if its turn had already ended.
|
||||
if (asked != null && asked != chat && AgentChats.file(app, asked).isFile) {
|
||||
load(app, asked)
|
||||
prefs(app).edit().putString(CHAT_KEY, asked).apply()
|
||||
}
|
||||
if (asked != null || interrupted(entries)) send(app, app.getString(R.string.agent_resumed))
|
||||
}
|
||||
|
||||
/** True when DroidDeck restarted in the middle of one of the agent's turns. */
|
||||
fun resuming(context: Context) = File(context.applicationContext.filesDir, RESUME).isFile
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun interrupted(entries: List<Entry>) = entries.isNotEmpty() && entries.last() !is Entry.Finished
|
||||
|
||||
/** Switches the agent CLI; a conversation belongs to one CLI, so a new one starts. */
|
||||
fun choose(context: Context, choice: AgentHarness) {
|
||||
if (choice == harness || state == State.WORKING || AgentSetup.busy) return
|
||||
forget(context)
|
||||
AgentSetup.forget()
|
||||
prefs(context).edit().putString(HARNESS_KEY, choice.id).apply()
|
||||
refresh(context)
|
||||
}
|
||||
|
||||
fun chooseModel(context: Context, id: String?) {
|
||||
model = id
|
||||
prefs(context).edit().putString(modelKey(harness), id).apply()
|
||||
}
|
||||
|
||||
fun chooseEffort(context: Context, level: String?) {
|
||||
effort = level
|
||||
prefs(context).edit().putString(effortKey(harness), level).apply()
|
||||
}
|
||||
|
||||
fun choosePlan(context: Context, on: Boolean) {
|
||||
plan = on
|
||||
prefs(context).edit().putBoolean(PLAN_KEY, on).apply()
|
||||
}
|
||||
|
||||
fun models(context: Context) = harness.models(LinuxRuntime.rootDir(context.applicationContext))
|
||||
|
||||
/** Sends [text] now, or after the current turn when the agent is working. */
|
||||
fun send(context: Context, text: String, files: List<String> = emptyList()) {
|
||||
val app = context.applicationContext
|
||||
val message = text.trim()
|
||||
if (message.isEmpty() && files.isEmpty()) return
|
||||
cancelResend()
|
||||
if (state == State.WORKING) {
|
||||
queue += Queued(message, files)
|
||||
return
|
||||
}
|
||||
if (state != State.IDLE) return
|
||||
val id = chat ?: AgentChats.newId(app).also { id ->
|
||||
AgentChats.start(AgentChats.file(app, id), harness.id)
|
||||
chat = id
|
||||
conversation = null
|
||||
prefs(app).edit().putString(CHAT_KEY, id).apply()
|
||||
}
|
||||
val attached = AgentAttachments.adopt(app, id, files)
|
||||
record(app, Entry.Asked(message, attached))
|
||||
state = State.WORKING
|
||||
val gen = ++generation
|
||||
live = ""
|
||||
liveThinking = ""
|
||||
turnStarted = SystemClock.elapsedRealtime()
|
||||
AgentHostService.start(app)?.let { serviceWarning(app, it) }
|
||||
val current = harness
|
||||
val prompt = AgentAttachments.prompt(message, attached)
|
||||
turnPlanned = plan && current.plans
|
||||
val options = AgentHarness.Options(model, turnPlanned, BRIEF, effort)
|
||||
val command = current.turn(prompt, conversation, options)
|
||||
val line = current.input(prompt)
|
||||
val key = "${current.id}|$id|$model|$turnPlanned|$effort"
|
||||
background = false
|
||||
val kept = session
|
||||
if (kept != null && line != null && sessionKey == key && kept.process.isAlive) {
|
||||
main.removeCallbacks(reap)
|
||||
turn = kept
|
||||
kept.writingGeneration = gen
|
||||
kept.clearingCosts = prompt == "/clear"
|
||||
Thread({
|
||||
val written = runCatching { synchronized(kept) { kept.stdin?.apply { write((line + "\n").toByteArray()); flush() } != null } }.getOrDefault(false)
|
||||
// The process died between turns: the same message goes to a new one, which resumes the conversation.
|
||||
main.post {
|
||||
if (kept.writingGeneration == gen) kept.writingGeneration = null
|
||||
if (generation == gen && session === kept) {
|
||||
if (!written) {
|
||||
dropSession()
|
||||
turn = null
|
||||
spawn(app, gen, current, current.turn(prompt, conversation, options), line, key)
|
||||
} else kept.exitStatus?.let { processExited(app, kept, current, it) }
|
||||
}
|
||||
}
|
||||
}, "agent-input").start()
|
||||
return
|
||||
}
|
||||
dropSession()
|
||||
spawn(app, gen, current, command, line, key)
|
||||
}
|
||||
|
||||
private fun spawn(app: Context, gen: Int, current: AgentHarness, command: List<String>, line: String?, key: String) {
|
||||
val workdir = workspace(app)
|
||||
var threadConversation = conversation
|
||||
Thread({
|
||||
runCatching { current.prepare(LinuxRuntime.rootDir(app)) }
|
||||
runCatching { AgentSetup.installHelpers(app) }
|
||||
// Without a session nothing else keeps the userland's resolver current.
|
||||
runCatching { com.droiddeck.launcher.runtime.LinuxNetworkLinkComponent(app, LinuxRuntime.rootDir(app)).publish() }
|
||||
val child = try {
|
||||
guest(app, command, workdir).start()
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "could not start ${current.name}", e)
|
||||
main.post { if (generation == gen) finish(app, e.message ?: "could not start") }
|
||||
return@Thread
|
||||
}
|
||||
val started = Turn(child, AgentProcesses.pidOf(child), if (line != null) child.outputStream else null).apply {
|
||||
if (current === ClaudeCode && line != null) costs = AgentCostTracker()
|
||||
}
|
||||
OrphanReaper.keep(started.pid)
|
||||
main.post {
|
||||
if (generation == gen && state == State.WORKING && turn == null) {
|
||||
turn = started
|
||||
if (line != null) { session = started; sessionKey = key }
|
||||
} else AgentProcesses.killTree(started.pid)
|
||||
}
|
||||
if (line != null) runCatching { child.outputStream.apply { write((line + "\n").toByteArray()); flush() } } else child.outputStream.close()
|
||||
val raw = runCatching {
|
||||
val log = File(app.filesDir, TURN_LOG).apply { parentFile?.mkdirs() }
|
||||
log.renameTo(File(app.filesDir, "$TURN_LOG.1"))
|
||||
log.bufferedWriter()
|
||||
}.getOrNull()
|
||||
runCatching {
|
||||
child.inputStream.bufferedReader().forEachLine { output ->
|
||||
runCatching { raw?.apply { write(output); newLine(); flush() } }
|
||||
val parsed = current.parse(output) ?: return@forEachLine
|
||||
parsed.conversation?.let { threadConversation = it }
|
||||
val done = parsed.entries.any { it is Entry.Finished }
|
||||
val event = if (!done) parsed else runCatching { current.usage(LinuxRuntime.rootDir(app), threadConversation) }.getOrNull()
|
||||
?.let { parsed.copy(context = it.context ?: parsed.context, window = it.window ?: parsed.window, limits = it.limits ?: parsed.limits) } ?: parsed
|
||||
main.post { if (turn === started || session === started) handle(app, started, event) }
|
||||
}
|
||||
}
|
||||
runCatching { raw?.close() }
|
||||
val status = runCatching { child.waitFor() }.getOrDefault(-1)
|
||||
OrphanReaper.release(started.pid)
|
||||
main.post {
|
||||
if (started.writingGeneration != null) started.exitStatus = status
|
||||
else processExited(app, started, current, status)
|
||||
}
|
||||
}, "agent-output").start()
|
||||
}
|
||||
|
||||
private fun processExited(app: Context, exited: Turn, current: AgentHarness, status: Int) {
|
||||
if (session === exited) {
|
||||
session = null
|
||||
launchedBackground = false
|
||||
main.removeCallbacks(reap)
|
||||
AgentHostService.backgroundDone(app)
|
||||
}
|
||||
if (turn === exited) {
|
||||
turn = null
|
||||
if (state == State.WORKING) finish(app, app.getString(R.string.agent_exited, current.name, status))
|
||||
}
|
||||
}
|
||||
|
||||
private fun serviceWarning(app: Context, error: Throwable) {
|
||||
record(app, Entry.Notice("Unable to keep the agent running in the background: ${error.message ?: error.javaClass.simpleName}"))
|
||||
}
|
||||
|
||||
/** One event from the CLI, which may belong to a turn it started on its own once the user's has ended. */
|
||||
private fun handle(app: Context, from: Turn, event: AgentEvent) {
|
||||
if (event.background) {
|
||||
// A leftover task answered before the user's message is not the user's turn; one the CLI started is its own.
|
||||
if (background && state == State.WORKING) finish(app, event.backgroundError, usage = event.usage?.let { from.costs?.perTurn(it) ?: it })
|
||||
return
|
||||
}
|
||||
val content = event.text != null || event.thinking != null || event.entries.any { it !is Entry.Finished }
|
||||
if (content && state == State.IDLE && session === from) {
|
||||
main.removeCallbacks(reap)
|
||||
background = true
|
||||
turn = from
|
||||
turnPlanned = false
|
||||
state = State.WORKING
|
||||
live = ""
|
||||
liveThinking = ""
|
||||
turnStarted = SystemClock.elapsedRealtime()
|
||||
AgentHostService.start(app)?.let { serviceWarning(app, it) }
|
||||
}
|
||||
val finished = event.entries.filterIsInstance<Entry.Finished>().firstOrNull()
|
||||
if (finished != null && state == State.WORKING && from.clearingCosts) {
|
||||
if (finished.error == null) from.costs?.reset()
|
||||
from.clearingCosts = false
|
||||
}
|
||||
val applied = if (finished != null && state == State.WORKING && event.usage != null)
|
||||
event.copy(usage = from.costs?.perTurn(event.usage) ?: event.usage) else event
|
||||
apply(app, applied)
|
||||
}
|
||||
|
||||
/** Ends the CLI process kept between turns, and with it whatever it still runs in the background. */
|
||||
private fun dropSession() {
|
||||
main.removeCallbacks(reap)
|
||||
launchedBackground = false
|
||||
appContext?.let { AgentHostService.backgroundDone(it) }
|
||||
val kept = session ?: return
|
||||
session = null
|
||||
AgentProcesses.killTree(kept.pid)
|
||||
kept.process.destroy()
|
||||
}
|
||||
|
||||
/** Ends the turn now: its process and everything it started, a build included. */
|
||||
fun stop(context: Context) {
|
||||
val app = context.applicationContext
|
||||
val running = turn
|
||||
turn = null
|
||||
queue.clear()
|
||||
if (labFromTurn && lab?.running == true) cancelLabBuild(app)
|
||||
if (running != null) {
|
||||
AgentProcesses.killTree(running.pid)
|
||||
running.process.destroy()
|
||||
}
|
||||
dropSession()
|
||||
if (state == State.WORKING) finish(app, null, stopped = true)
|
||||
}
|
||||
|
||||
fun unqueue(item: Queued) {
|
||||
queue.remove(item)
|
||||
}
|
||||
|
||||
/** Sends [item] now: the running turn stops where it is, and the rest of the queue waits for the next one. */
|
||||
fun sendNow(context: Context, item: Queued) {
|
||||
val app = context.applicationContext
|
||||
if (!queue.remove(item)) return
|
||||
val rest = queue.toList()
|
||||
stop(app)
|
||||
queue.addAll(rest)
|
||||
send(app, item.text, item.files)
|
||||
}
|
||||
|
||||
/** Starts a new conversation; the current one stays in the history. */
|
||||
fun forget(context: Context) {
|
||||
stop(context)
|
||||
entries.clear()
|
||||
if (chat != null) AgentAttachments.pending.clear()
|
||||
chat = null
|
||||
conversation = null
|
||||
this.context = 0
|
||||
window = 0
|
||||
prefs(context).edit().remove(CHAT_KEY).apply()
|
||||
state = if (installed) State.IDLE else State.MISSING
|
||||
}
|
||||
|
||||
/**
|
||||
* A process for [command] in the Linux userland, run the way the store helpers run theirs:
|
||||
* proot over the installed rootfs, without a session. Loopback adb is connected first so
|
||||
* droiddeckctl reaches the app.
|
||||
*/
|
||||
fun guest(app: Context, command: List<String>, workdir: String = "/root", connectAdb: Boolean = true, fakeRoot: Boolean = false): ProcessBuilder {
|
||||
val adb = AgentAdb.prepare(app)
|
||||
val env = listOf(
|
||||
"/usr/bin/env", "HOME=/root", "PATH=$GUEST_PATH", "LANG=C.UTF-8",
|
||||
"ADB_SERIAL=${adb.serial}", "ADB_VENDOR_KEYS=${adb.vendorKeys}", "DROIDDECK_PACKAGE=${app.packageName}",
|
||||
"DD_AGENT=1", "DD_AGENT_INBOX=${File(app.filesDir, "agent").path}", "BROWSER=/root/.local/bin/android-open", "DD_BROWSER_DISPLAY=${AgentAdb.browserDisplay}",
|
||||
)
|
||||
val shell = listOf(
|
||||
"/bin/sh", "-c",
|
||||
// proot ends the adb server with the command, so each command that needs adb connects it.
|
||||
(if (connectAdb) "adb start-server >/dev/null 2>&1; adb connect \"\$ADB_SERIAL\" >/dev/null 2>&1; " else "") +
|
||||
"cd \"$1\" 2>/dev/null; shift; exec \"$@\"", "sh", workdir,
|
||||
)
|
||||
val proot = LinuxRuntime.command(app, null, null, Environment.getExternalStorageDirectory(), null, env + shell + command, fakeRoot)
|
||||
return ProcessBuilder(proot).redirectErrorStream(true).apply {
|
||||
environment().apply {
|
||||
remove("LD_PRELOAD"); remove("LD_AUDIT"); remove("LD_LIBRARY_PATH")
|
||||
put("PROOT_LOADER", LinuxRuntime.prootLoader(app).path)
|
||||
put("PROOT_TMP_DIR", LinuxRuntime.prootTempDir(app).path)
|
||||
if (SessionPrefs.prootNoSeccomp(app)) put("PROOT_NO_SECCOMP", "1")
|
||||
LinuxRuntime.prootLibraryPath(app).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun guestFileExists(context: Context, path: String): Boolean {
|
||||
val file = File(LinuxRuntime.rootDir(context), path.removePrefix("/"))
|
||||
return file.exists() || Files.isSymbolicLink(file.toPath())
|
||||
}
|
||||
|
||||
private fun workspace(app: Context) = if (guestFileExists(app, WORKSPACE)) WORKSPACE else "/root"
|
||||
|
||||
private fun apply(app: Context, event: AgentEvent) {
|
||||
event.conversation?.takeIf { it != conversation }?.let { id ->
|
||||
conversation = id
|
||||
chat?.let { AgentChats.appendConversation(AgentChats.file(app, it), id) }
|
||||
}
|
||||
event.text?.let { live += it }
|
||||
event.thinking?.let { liveThinking += it }
|
||||
event.context?.let { context = it }
|
||||
event.window?.let { window = it }
|
||||
event.limits?.let { reported ->
|
||||
limits = (limits.filter { old -> reported.none { it.minutes == old.minutes } } + reported).sortedBy { it.minutes }
|
||||
prefs(app).edit().putString(limitsKey(harness), encodeLimits(limits)).apply()
|
||||
}
|
||||
for (entry in event.entries) when (entry) {
|
||||
is Entry.Finished -> finish(app, entry.error, usage = event.usage)
|
||||
else -> {
|
||||
if (entry is Entry.Said) live = ""
|
||||
if (entry is Entry.Thought) liveThinking = ""
|
||||
record(app, entry)
|
||||
}
|
||||
}
|
||||
AgentHostService.update(app)
|
||||
}
|
||||
|
||||
private fun finish(app: Context, error: String?, stopped: Boolean = false, usage: Usage? = null) {
|
||||
if (state != State.WORKING) return
|
||||
turn = null
|
||||
val answeredTask = background
|
||||
background = false
|
||||
main.removeCallbacks(reap)
|
||||
if (session != null) main.postDelayed(reap, LINGER_MS)
|
||||
if (!stopped) labFromTurn = false
|
||||
live = ""
|
||||
liveThinking = ""
|
||||
val held = if (context > 0) (usage ?: Usage(0, 0.0, 0, 0)).copy(context = context, window = window) else usage
|
||||
state = State.IDLE
|
||||
unseen = true
|
||||
failed = error != null
|
||||
if (session != null && launchedBackground) {
|
||||
AgentHostService.waitForBackground(app)?.let { serviceWarning(app, it) }
|
||||
} else AgentHostService.stop(app)
|
||||
record(app, Entry.Finished(error, stopped, held, planned = turnPlanned && !stopped && error == null))
|
||||
// Claude Code now and then ends a resumed turn at once without reading the message; nothing
|
||||
// happened, so the message is sent once more.
|
||||
val asked = entries.lastOrNull { it is Entry.Asked } as? Entry.Asked
|
||||
if (!stopped && error == null && !answeredTask && asked != null && answerless(entries) && !retrying) {
|
||||
retrying = true
|
||||
val retryChat = chat
|
||||
resend = Runnable {
|
||||
resend = null
|
||||
if (state == State.IDLE && chat == retryChat) send(app, asked.text, asked.files) else retrying = false
|
||||
}.also { main.postDelayed(it, RETRY_MS) }
|
||||
return
|
||||
}
|
||||
retrying = false
|
||||
if (!stopped && queue.isNotEmpty()) {
|
||||
val next = queue.removeAt(0)
|
||||
send(app, next.text, next.files)
|
||||
} else if (!stopped) notifyEnded(app, error)
|
||||
}
|
||||
|
||||
private fun notifyEnded(app: Context, error: String?) {
|
||||
val start = entries.indexOfLast { it is Entry.Asked }
|
||||
val said = entries.subList(start + 1, entries.size).lastOrNull { it is Entry.Said } as? Entry.Said
|
||||
val reply = said?.let { choices(it.text) }
|
||||
val kind = when {
|
||||
error != null -> AgentNotice.Kind.FAILED
|
||||
!reply?.options.isNullOrEmpty() -> AgentNotice.Kind.QUESTION
|
||||
else -> AgentNotice.Kind.DONE
|
||||
}
|
||||
AgentNotice.post(app, kind, error ?: reply?.text?.takeIf { it.isNotBlank() }?.let { firstLine(it) } ?: "")
|
||||
}
|
||||
|
||||
/** A message typed or retried by the user replaces the automatic resend. */
|
||||
private fun cancelResend() {
|
||||
val pending = resend ?: return
|
||||
main.removeCallbacks(pending)
|
||||
resend = null
|
||||
retrying = false
|
||||
}
|
||||
|
||||
private fun record(app: Context, entry: Entry) {
|
||||
if (!AgentChats.merge(entries, entry)) return
|
||||
if (entry is Entry.Used && entry.background) launchedBackground = true
|
||||
chat?.let { AgentChats.append(AgentChats.file(app, it), entry) }
|
||||
}
|
||||
|
||||
/** The last turn ended without saying or doing anything. */
|
||||
fun answerless(entries: List<Entry>): Boolean {
|
||||
val start = entries.indexOfLast { it is Entry.Asked }
|
||||
if (start < 0) return false
|
||||
val turn = entries.subList(start + 1, entries.size)
|
||||
return turn.lastOrNull() is Entry.Finished && turn.none { it is Entry.Said || it is Entry.Used || it is Entry.Thought } &&
|
||||
(turn.last() as Entry.Finished).let { it.error == null && !it.stopped }
|
||||
}
|
||||
|
||||
/** Sends the last message again, after a turn that ended without a reply. */
|
||||
fun retry(context: Context) {
|
||||
val asked = entries.lastOrNull { it is Entry.Asked } as? Entry.Asked ?: return
|
||||
send(context, asked.text, asked.files)
|
||||
}
|
||||
|
||||
/** The tool call still running in this turn, if any. */
|
||||
fun running(): Entry.Used? {
|
||||
if (state != State.WORKING) return null
|
||||
val start = entries.indexOfLast { it is Entry.Asked }
|
||||
return entries.withIndex().lastOrNull { (i, e) -> i > start && e is Entry.Used && e.output == null }?.value as? Entry.Used
|
||||
}
|
||||
|
||||
/** The latest todo list the agent wrote in this conversation. */
|
||||
fun todos(): String? = entries.lastOrNull { it is Entry.Used && it.tool == "TodoWrite" && it.parent.isEmpty() }?.let { (it as Entry.Used).input }
|
||||
|
||||
private fun tick() {
|
||||
now = SystemClock.elapsedRealtime()
|
||||
appContext?.let { app ->
|
||||
claimLabRequest(app)
|
||||
claimOpenUrl(app)
|
||||
claimDeviceCode(app)
|
||||
// proot comes from an add-on pack fetched after the app starts, so the runtime can become usable later.
|
||||
if (!available && state != State.WORKING) available = LinuxRuntime.hasRootfs(app)
|
||||
lab = LabProgress.read(LinuxRuntime.rootDir(app))
|
||||
AgentHostService.update(app)
|
||||
}
|
||||
val busy = state == State.WORKING || lab != null || AgentSetup.status.values.any { it == AgentSetup.Status.WORKING }
|
||||
main.postDelayed(::tick, if (busy) TICK_MS else IDLE_TICK_MS)
|
||||
}
|
||||
|
||||
/**
|
||||
* android-open, the userland's $BROWSER, leaves a URL here for the app to open, so sign-ins
|
||||
* work without Wireless debugging.
|
||||
*/
|
||||
private fun claimOpenUrl(app: Context) {
|
||||
val request = File(app.filesDir, OPEN_URL)
|
||||
if (!request.isFile) return
|
||||
val claimed = File(app.filesDir, "$OPEN_URL.claimed")
|
||||
if (!request.renameTo(claimed)) return
|
||||
val url = runCatching { claimed.readText().trim() }.getOrNull()
|
||||
claimed.delete()
|
||||
if (url == null || !(url.startsWith("https://") || url.startsWith("http://"))) return
|
||||
if (!openUrl(app, url)) runCatching { File(app.filesDir, "$OPEN_URL.failed").writeText("") }
|
||||
}
|
||||
|
||||
/** dd-gh-login leaves "<code> <url>" here to float the code over the page, and an empty file when it ends. */
|
||||
private fun claimDeviceCode(app: Context) {
|
||||
val request = File(app.filesDir, DEVICE_CODE)
|
||||
if (!request.isFile) return
|
||||
val claimed = File(app.filesDir, "$DEVICE_CODE.claimed")
|
||||
if (!request.renameTo(claimed)) return
|
||||
val parts = runCatching { claimed.readText().trim() }.getOrDefault("").split(' ', limit = 2)
|
||||
claimed.delete()
|
||||
val code = parts[0]
|
||||
val url = parts.getOrNull(1)?.takeIf { it.startsWith("https://") }
|
||||
if (code.isEmpty() || url == null) {
|
||||
com.droiddeck.launcher.DeviceCodeActivity.close()
|
||||
return
|
||||
}
|
||||
if (!com.droiddeck.launcher.DeviceCodeActivity.show(app, code, url, AgentAdb.browserDisplay)) deviceCodeOpened(app, openUrl(app, url))
|
||||
}
|
||||
|
||||
/** Tells dd-gh-login whether the device page opened, so it can fall back to android-open. */
|
||||
fun deviceCodeOpened(app: Context, opened: Boolean) {
|
||||
runCatching {
|
||||
val part = File(app.filesDir, "$DEVICE_CODE.result.part")
|
||||
part.writeText(if (opened) "ok" else "failed")
|
||||
part.renameTo(File(app.filesDir, "$DEVICE_CODE.result"))
|
||||
}
|
||||
}
|
||||
|
||||
private fun openUrl(app: Context, url: String): Boolean {
|
||||
val intent = android.content.Intent(android.content.Intent.ACTION_VIEW, android.net.Uri.parse(url))
|
||||
.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
val options = android.app.ActivityOptions.makeBasic().setLaunchDisplayId(AgentAdb.browserDisplay).toBundle()
|
||||
return runCatching { app.startActivity(intent, options) }
|
||||
.recoverCatching { app.startActivity(intent) }
|
||||
.onFailure { Log.w(TAG, "could not open a sign-in link: ${it.javaClass.simpleName}") }
|
||||
.isSuccess
|
||||
}
|
||||
|
||||
/**
|
||||
* dd-lab-build run by the agent hands its build to the app: the turn's processes end with the
|
||||
* turn, and a build must outlive a turn that ends early or is stopped.
|
||||
*/
|
||||
private fun claimLabRequest(app: Context) {
|
||||
val request = File(app.filesDir, LAB_REQUEST)
|
||||
if (!request.isFile) return
|
||||
val claimed = File(app.filesDir, "$LAB_REQUEST.claimed")
|
||||
if (!request.renameTo(claimed)) return
|
||||
val o = runCatching { org.json.JSONObject(claimed.readText()) }.getOrNull()
|
||||
claimed.delete()
|
||||
if (o == null || labProcess?.isAlive == true) return
|
||||
val args = o.optJSONArray("args")?.let { a -> (0 until a.length()).map { a.getString(it) } }.orEmpty()
|
||||
val cwd = o.optString("cwd").ifEmpty { WORKSPACE }
|
||||
labFromTurn = state == State.WORKING
|
||||
chat?.let { prefs(app).edit().putString(LAB_CHAT_KEY, it).apply() }
|
||||
AgentHostService.setupStarted(app)
|
||||
Thread({
|
||||
runCatching {
|
||||
val child = guest(app, listOf("sh", "-c",
|
||||
"mkdir -p /root/.cache; DD_LAB_DETACHED=1 exec dd-lab-build \"\$@\" > /root/.cache/dd-lab-build.log 2>&1", "dd-lab-build") + args, cwd).start()
|
||||
main.post { labProcess = child }
|
||||
val pid = AgentProcesses.pidOf(child)
|
||||
OrphanReaper.keep(pid)
|
||||
try {
|
||||
child.outputStream.close()
|
||||
child.inputStream.readBytes()
|
||||
child.waitFor()
|
||||
} finally {
|
||||
OrphanReaper.release(pid)
|
||||
}
|
||||
}.onFailure { Log.w(TAG, "could not run a Lab build", it) }
|
||||
main.post {
|
||||
labProcess = null
|
||||
labFromTurn = false
|
||||
AgentHostService.setupEnded(app)
|
||||
}
|
||||
}, "agent-lab-build").start()
|
||||
}
|
||||
|
||||
fun cancelLabBuild(context: Context) {
|
||||
val progress = lab ?: return
|
||||
LabProgress.cancel(LinuxRuntime.rootDir(context.applicationContext), progress)
|
||||
lab = LabProgress.read(LinuxRuntime.rootDir(context.applicationContext))
|
||||
}
|
||||
|
||||
private const val LEGACY_CONVERSATION_KEY = "session_id"
|
||||
private const val HARNESS_KEY = "harness"
|
||||
private const val CHAT_KEY = "chat"
|
||||
private const val PLAN_KEY = "plan"
|
||||
private const val RESUME = "agent/resume"
|
||||
private const val LAB_REQUEST = "agent/lab-request"
|
||||
private const val OPEN_URL = "agent/open-url"
|
||||
private const val DEVICE_CODE = "agent/device-code"
|
||||
private const val LAB_CHAT_KEY = "lab_chat"
|
||||
/** The raw output of the latest turn, for working out what a CLI did when the chat shows nothing. */
|
||||
private const val TURN_LOG = "agent/turn.log"
|
||||
private const val RETRY_MS = 3_000L
|
||||
/** How long the CLI process stays open after a turn, waiting for background work to wake it. */
|
||||
private const val LINGER_MS = 20 * 60_000L
|
||||
|
||||
private fun modelKey(harness: AgentHarness) = "model_${harness.id}"
|
||||
private fun limitsKey(harness: AgentHarness) = "limits_${harness.id}"
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun encodeLimits(list: List<Limit>) = org.json.JSONArray(list.map {
|
||||
org.json.JSONObject().put("minutes", it.minutes).put("used", it.usedPercent).put("resets", it.resetsAt)
|
||||
}).toString()
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun decodeLimits(text: String?): List<Limit> = runCatching {
|
||||
val a = org.json.JSONArray(text ?: return emptyList())
|
||||
(0 until a.length()).map { a.getJSONObject(it) }.map { Limit(it.optInt("minutes"), it.optInt("used"), it.optLong("resets")) }
|
||||
}.getOrDefault(emptyList())
|
||||
private fun effortKey(harness: AgentHarness) = "effort_${harness.id}"
|
||||
|
||||
internal fun prefs(context: Context) = context.getSharedPreferences("agent", Context.MODE_PRIVATE)
|
||||
}
|
||||
|
||||
/** A reply split into its text and the options of a trailing choices block. */
|
||||
internal data class Choices(val text: String, val options: List<String>)
|
||||
|
||||
private val FENCE = Regex("""[ \t]{0,3}(`{3,}|~{3,})(.*)""")
|
||||
|
||||
/** Walks Markdown fences so a choices block counts only at the top level and only as the last thing in the reply. */
|
||||
internal fun choices(reply: String): Choices {
|
||||
val lines = reply.split('\n')
|
||||
var open = ""
|
||||
var opener = -1
|
||||
var openChoices = false
|
||||
var block: IntRange? = null
|
||||
lines.forEachIndexed { i, line ->
|
||||
val fence = FENCE.matchEntire(line)
|
||||
if (open.isEmpty()) {
|
||||
if (fence != null) {
|
||||
open = fence.groupValues[1]
|
||||
opener = i
|
||||
openChoices = fence.groupValues[2].trim() == "choices"
|
||||
block = null
|
||||
} else if (line.isNotBlank()) block = null
|
||||
} else if (fence != null && fence.groupValues[1][0] == open[0] && fence.groupValues[1].length >= open.length && fence.groupValues[2].isBlank()) {
|
||||
block = if (openChoices) opener..i else null
|
||||
open = ""
|
||||
}
|
||||
}
|
||||
val found = block?.takeIf { open.isEmpty() } ?: return Choices(reply, emptyList())
|
||||
val options = lines.subList(found.first + 1, found.last).map { it.trim().removePrefix("- ").removePrefix("* ").trim() }.filter { it.isNotEmpty() }
|
||||
return Choices(lines.subList(0, found.first).joinToString("\n").trimEnd(), options)
|
||||
}
|
||||
|
||||
internal class AgentCostTracker {
|
||||
private var previous = 0.0
|
||||
|
||||
fun reset() { previous = 0.0 }
|
||||
|
||||
fun perTurn(usage: AgentHost.Usage): AgentHost.Usage {
|
||||
val total = usage.costUsd
|
||||
if (total == 0.0 && previous > 0.0) return usage
|
||||
val delta = if (total >= previous) total - previous else total
|
||||
previous = total
|
||||
return usage.copy(costUsd = delta)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.app.Notification
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.app.Service
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.os.IBinder
|
||||
import android.os.SystemClock
|
||||
import com.droiddeck.launcher.FrontEndActivity
|
||||
import com.droiddeck.launcher.R
|
||||
|
||||
/** Keeps the app process alive while the agent works, and says what it is doing, with a way to stop it. */
|
||||
class AgentHostService : Service() {
|
||||
override fun onBind(intent: Intent?): IBinder? = null
|
||||
|
||||
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
|
||||
if (intent?.action == ACTION_STOP) {
|
||||
if (AgentHost.lab?.running == true) AgentHost.cancelLabBuild(this)
|
||||
AgentHost.stop(this)
|
||||
return START_NOT_STICKY
|
||||
}
|
||||
awaiting = (awaiting - 1).coerceAtLeast(0)
|
||||
startForeground(NOTIFICATION_ID, build(this))
|
||||
if (!started && awaiting == 0) stopSelf()
|
||||
return START_NOT_STICKY
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val CHANNEL_ID = "agent"
|
||||
private const val NOTIFICATION_ID = 4107
|
||||
private const val ACTION_STOP = "com.droiddeck.launcher.agent.STOP"
|
||||
private var lastText: String? = null
|
||||
@Volatile private var started = false
|
||||
/**
|
||||
* startForegroundService calls not yet answered by onStartCommand. Stopping the service
|
||||
* before it calls startForeground crashes the app, so it then stops itself instead.
|
||||
*/
|
||||
private var awaiting = 0
|
||||
/** Setup steps that keep the app alive while they run, besides the agent's turn. */
|
||||
private var setupSteps = 0
|
||||
|
||||
fun start(context: Context): Throwable? {
|
||||
if (started) { update(context); return null }
|
||||
lastText = null
|
||||
return runCatching { context.startForegroundService(Intent(context, AgentHostService::class.java)) }
|
||||
.onSuccess { started = true; awaiting++ }
|
||||
.exceptionOrNull()
|
||||
}
|
||||
|
||||
fun stop(context: Context) {
|
||||
if (setupSteps > 0 || waiting) return
|
||||
started = false
|
||||
if (awaiting == 0) context.stopService(Intent(context, AgentHostService::class.java))
|
||||
}
|
||||
|
||||
/**
|
||||
* The turn has ended but its CLI process stays open with background work that can wake it; the app must stay
|
||||
* alive to read that answer, so the service keeps running until the process is dropped.
|
||||
*/
|
||||
@Volatile private var waiting = false
|
||||
|
||||
fun waitForBackground(context: Context): Throwable? {
|
||||
waiting = true
|
||||
return if (started) { update(context); null } else start(context)
|
||||
}
|
||||
|
||||
fun backgroundDone(context: Context) {
|
||||
if (!waiting) return
|
||||
waiting = false
|
||||
if (AgentHost.state != AgentHost.State.WORKING) stop(context)
|
||||
}
|
||||
|
||||
fun setupStarted(context: Context) {
|
||||
setupSteps++
|
||||
start(context)
|
||||
}
|
||||
|
||||
fun setupEnded(context: Context) {
|
||||
setupSteps = (setupSteps - 1).coerceAtLeast(0)
|
||||
if (AgentHost.state != AgentHost.State.WORKING) stop(context)
|
||||
}
|
||||
|
||||
/** Refreshes the notification with the current step; unchanged text is not re-posted. */
|
||||
fun update(context: Context) {
|
||||
if (!started) return
|
||||
val text = describe(context)
|
||||
if (text == lastText) return
|
||||
lastText = text
|
||||
context.getSystemService(NotificationManager::class.java)?.notify(NOTIFICATION_ID, build(context))
|
||||
}
|
||||
|
||||
private fun describe(context: Context): String {
|
||||
val lab = AgentHost.lab?.takeIf { it.running }
|
||||
if (lab != null) return context.getString(R.string.agent_lab_progress, lab.permille / 10, minutes(lab.etaSeconds.toLong().coerceAtLeast(0)))
|
||||
AgentSetup.detail[AgentSetup.Step.GITHUB]?.takeIf {
|
||||
AgentSetup.status[AgentSetup.Step.GITHUB] == AgentSetup.Status.WORKING && it.startsWith("GitHub device code:")
|
||||
}?.let { return it }
|
||||
if (AgentHost.state != AgentHost.State.WORKING)
|
||||
return context.getString(if (waiting && setupSteps == 0) R.string.agent_waiting_background else R.string.agent_setting_up)
|
||||
val tool = AgentHost.running()
|
||||
val elapsed = minutes((SystemClock.elapsedRealtime() - AgentHost.turnStarted) / 1000)
|
||||
return if (tool != null) "${tool.tool} · ${tool.detail}".take(120) + " · $elapsed" else context.getString(R.string.agent_thinking_for, elapsed)
|
||||
}
|
||||
|
||||
private fun minutes(seconds: Long) = if (seconds < 60) "${seconds.coerceAtLeast(0)}s" else "${seconds / 60}m ${seconds % 60}s"
|
||||
|
||||
private fun build(context: Context): Notification {
|
||||
val manager = context.getSystemService(NotificationManager::class.java)
|
||||
manager?.createNotificationChannel(NotificationChannel(CHANNEL_ID, context.getString(R.string.agent_channel_name),
|
||||
NotificationManager.IMPORTANCE_LOW).apply { setShowBadge(false) })
|
||||
val open = PendingIntent.getActivity(context, 0,
|
||||
Intent(context, FrontEndActivity::class.java)
|
||||
.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
|
||||
.putExtra(com.droiddeck.launcher.stores.download.StoreDownloadService.EXTRA_NAV, "agent"),
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
|
||||
val stop = PendingIntent.getService(context, 1, Intent(context, AgentHostService::class.java).setAction(ACTION_STOP),
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
|
||||
val lab = AgentHost.lab?.takeIf { it.running }
|
||||
return Notification.Builder(context, CHANNEL_ID)
|
||||
.setSmallIcon(R.drawable.ic_stat_session)
|
||||
.setContentTitle(context.getString(when {
|
||||
lab?.prepare == true -> R.string.agent_lab_preparing
|
||||
lab != null -> R.string.agent_lab_building
|
||||
else -> R.string.agent_working
|
||||
}))
|
||||
.setContentText(describe(context))
|
||||
.setContentIntent(open)
|
||||
.addAction(Notification.Action.Builder(null, context.getString(R.string.agent_stop), stop).build())
|
||||
.setOngoing(true)
|
||||
.setOnlyAlertOnce(true)
|
||||
.setShowWhen(false)
|
||||
.apply { if (lab != null) setProgress(1000, lab.permille, lab.stage != "building") }
|
||||
.setCategory(Notification.CATEGORY_PROGRESS)
|
||||
.build()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import com.droiddeck.launcher.runtime.NativeGuest
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/** Runs a guest program without proot (`droiddeckctl native`), for testing the native userland. */
|
||||
object AgentNative {
|
||||
private const val OUTPUT_CAP = 256 * 1024
|
||||
|
||||
fun run(context: Context, request: JSONObject, timeoutMs: Long): JSONObject {
|
||||
val root = LinuxRuntime.rootDir(context)
|
||||
com.droiddeck.launcher.session.SessionFiles.stage(context, root)
|
||||
// with the setting off, staging leaves the rootfs as proot wants it
|
||||
if (!com.droiddeck.launcher.session.SessionPrefs.nativeUserland(context)) NativeGuest.prepare(context, root)
|
||||
if (!NativeGuest.available(root)) throw AgentException("NATIVE_UNAVAILABLE", "The rootfs has no native hook or glibc loader yet; start a session once")
|
||||
val argvJson = request.optJSONArray("argv") ?: throw AgentException("INVALID_REQUEST", "argv is required")
|
||||
val argv = (0 until argvJson.length()).map { argvJson.getString(it) }
|
||||
if (argv.isEmpty()) throw AgentException("INVALID_REQUEST", "argv is empty")
|
||||
val env = linkedMapOf<String, String>()
|
||||
request.optJSONObject("env")?.let { obj -> obj.keys().forEach { env[it] = obj.getString(it) } }
|
||||
val preload = request.optJSONArray("preload")?.let { a -> (0 until a.length()).map { a.getString(it) } } ?: emptyList()
|
||||
val builder = NativeGuest.builder(root, request.optString("cwd", "/root"), argv, env, preload)
|
||||
val started = System.nanoTime()
|
||||
val process = builder.start()
|
||||
val out = StringBuilder()
|
||||
val err = StringBuilder()
|
||||
val readers = listOf(
|
||||
Thread { drain(process.inputStream, out) },
|
||||
Thread { drain(process.errorStream, err) },
|
||||
).onEach { it.isDaemon = true; it.start() }
|
||||
// written beside the wait: a program that never reads more than a pipe holds would block it
|
||||
val input = request.optString("stdin").toByteArray()
|
||||
Thread {
|
||||
try {
|
||||
process.outputStream.use { stdin -> if (input.isNotEmpty()) stdin.write(input) }
|
||||
} catch (_: java.io.IOException) {
|
||||
}
|
||||
}.apply { isDaemon = true; start() }
|
||||
val finished = process.waitFor(timeoutMs, TimeUnit.MILLISECONDS)
|
||||
if (!finished) process.destroyForcibly().waitFor()
|
||||
readers.forEach { it.join(2000) }
|
||||
val code = if (finished) process.exitValue() else -1
|
||||
return JSONObject().put("ok", true).put("command", "native")
|
||||
.put("exitCode", code).put("timedOut", !finished)
|
||||
.put("ms", (System.nanoTime() - started) / 1_000_000)
|
||||
.put("stdout", JSONObject().put("text", out.toString()))
|
||||
.put("stderr", JSONObject().put("text", err.toString()))
|
||||
.put("argv", JSONArray(argv))
|
||||
}
|
||||
|
||||
private fun drain(input: java.io.InputStream, into: StringBuilder) {
|
||||
val buffer = ByteArray(8192)
|
||||
val text = java.io.ByteArrayOutputStream()
|
||||
while (true) {
|
||||
val n = try { input.read(buffer) } catch (e: java.io.IOException) { -1 }
|
||||
if (n < 0) break
|
||||
if (text.size() < OUTPUT_CAP) text.write(buffer, 0, minOf(n, OUTPUT_CAP - text.size()))
|
||||
}
|
||||
into.append(text.toString(Charsets.UTF_8.name()))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.app.ActivityManager
|
||||
import android.app.Notification
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import com.droiddeck.launcher.FrontEndActivity
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.ui.AgentPet
|
||||
|
||||
/** Tells the user a turn has ended when nothing on screen already does. */
|
||||
internal object AgentNotice {
|
||||
private const val CHANNEL_ID = "agent_done"
|
||||
private const val NOTIFICATION_ID = 4108
|
||||
|
||||
enum class Kind { DONE, FAILED, QUESTION }
|
||||
|
||||
fun post(context: Context, kind: Kind, text: String) {
|
||||
if (onScreen(context)) return
|
||||
val manager = context.getSystemService(NotificationManager::class.java) ?: return
|
||||
manager.createNotificationChannel(NotificationChannel(CHANNEL_ID, context.getString(R.string.agent_done_channel), NotificationManager.IMPORTANCE_DEFAULT))
|
||||
val open = PendingIntent.getActivity(context, 2,
|
||||
Intent(context, FrontEndActivity::class.java)
|
||||
.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
|
||||
.putExtra(com.droiddeck.launcher.stores.download.StoreDownloadService.EXTRA_NAV, "agent"),
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
|
||||
val title = context.getString(when (kind) {
|
||||
Kind.DONE -> R.string.agent_done
|
||||
Kind.FAILED -> R.string.agent_done_failed
|
||||
Kind.QUESTION -> R.string.agent_done_question
|
||||
})
|
||||
runCatching {
|
||||
manager.notify(NOTIFICATION_ID, Notification.Builder(context, CHANNEL_ID)
|
||||
.setSmallIcon(R.drawable.ic_stat_session)
|
||||
.setContentTitle(title)
|
||||
.setContentText(text)
|
||||
.setStyle(Notification.BigTextStyle().bigText(text))
|
||||
.setContentIntent(open)
|
||||
.setAutoCancel(true)
|
||||
.setCategory(Notification.CATEGORY_STATUS)
|
||||
.build())
|
||||
}
|
||||
}
|
||||
|
||||
fun clear(context: Context) {
|
||||
context.getSystemService(NotificationManager::class.java)?.cancel(NOTIFICATION_ID)
|
||||
}
|
||||
|
||||
/** The chat in a DroidDeck window in front, or the pet, which shows the reply in its own bubble. */
|
||||
private fun onScreen(context: Context): Boolean {
|
||||
if (AgentPet.floating) return true
|
||||
val state = ActivityManager.RunningAppProcessInfo().also { ActivityManager.getMyMemoryState(it) }
|
||||
return AgentPet.agentOnScreen > 0 && state.importance <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.os.Process
|
||||
import android.os.SystemClock
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* Linux userland processes, read from /proc: proot runs them as real processes under the app's
|
||||
* own uid, so the app can list and end them without a shell.
|
||||
*/
|
||||
object AgentProcesses {
|
||||
data class Proc(
|
||||
val pid: Int, val ppid: Int, val name: String, val args: String,
|
||||
val seconds: Long, val rssKb: Long, val cpuPercent: Int, val agent: Boolean,
|
||||
)
|
||||
|
||||
private const val HZ = 100L
|
||||
private var lastTicks = emptyMap<Int, Long>()
|
||||
private var lastAt = 0L
|
||||
|
||||
@VisibleForTesting
|
||||
internal class Stat(val pid: Int, val ppid: Int, val ticks: Long, val startTicks: Long, val rssPages: Long)
|
||||
|
||||
/** Guest processes, those under [turnPid] (the agent's current turn) first. */
|
||||
@Synchronized
|
||||
fun snapshot(turnPid: Int): List<Proc> {
|
||||
val me = Process.myPid()
|
||||
val uid = Process.myUid()
|
||||
val stats = HashMap<Int, Stat>()
|
||||
val args = HashMap<Int, String>()
|
||||
for (dir in File("/proc").listFiles().orEmpty()) {
|
||||
val pid = dir.name.toIntOrNull() ?: continue
|
||||
if (pid == me) continue
|
||||
val stat = runCatching { parseStat(File(dir, "stat").readText()) }.getOrNull() ?: continue
|
||||
if (!owned(dir, uid)) continue
|
||||
stats[pid] = stat
|
||||
args[pid] = runCatching { File(dir, "cmdline").readBytes().toString(Charsets.UTF_8).trimEnd('\u0000').replace('\u0000', ' ') }.getOrDefault("")
|
||||
}
|
||||
val now = SystemClock.elapsedRealtime()
|
||||
val uptimeTicks = now * HZ / 1000
|
||||
val elapsed = (now - lastAt).coerceAtLeast(1)
|
||||
fun isProot(pid: Int) = args[pid].orEmpty().substringBefore(' ').endsWith("proot.so") || args[pid].orEmpty().substringBefore(' ').endsWith("/proot")
|
||||
fun ancestors(pid: Int) = generateSequence(stats[pid]?.ppid) { stats[it]?.ppid }.takeWhile { it > 1 }.take(64)
|
||||
val out = stats.values.filter { s ->
|
||||
!isProot(s.pid) && args[s.pid].orEmpty().isNotEmpty() && ancestors(s.pid).any { isProot(it) }
|
||||
}.map { s ->
|
||||
val full = args[s.pid].orEmpty()
|
||||
val cpu = lastTicks[s.pid]?.let { ((s.ticks - it) * 1000 * 100 / HZ / elapsed).toInt().coerceIn(0, 800) } ?: 0
|
||||
Proc(
|
||||
s.pid, s.ppid, full.substringBefore(' ').substringAfterLast('/'), full,
|
||||
((uptimeTicks - s.startTicks) / HZ).coerceAtLeast(0), s.rssPages * 4, cpu,
|
||||
turnPid > 0 && ancestors(s.pid).any { it == turnPid },
|
||||
)
|
||||
}
|
||||
lastTicks = stats.mapValues { it.value.ticks }
|
||||
lastAt = now
|
||||
return out.sortedWith(compareByDescending<Proc> { it.agent }.thenBy { it.seconds })
|
||||
}
|
||||
|
||||
/** Ends [pid] and everything it started, children first so none is left to be re-parented. */
|
||||
fun killTree(pid: Int) {
|
||||
if (pid <= 0) return
|
||||
val children = HashMap<Int, MutableList<Int>>()
|
||||
for (dir in File("/proc").listFiles().orEmpty()) {
|
||||
val child = dir.name.toIntOrNull() ?: continue
|
||||
val stat = runCatching { parseStat(File(dir, "stat").readText()) }.getOrNull() ?: continue
|
||||
children.getOrPut(stat.ppid) { mutableListOf() } += child
|
||||
}
|
||||
val order = mutableListOf<Int>()
|
||||
fun walk(p: Int) {
|
||||
children[p].orEmpty().forEach(::walk)
|
||||
order += p
|
||||
}
|
||||
walk(pid)
|
||||
order.forEach { runCatching { Process.sendSignal(it, Process.SIGNAL_KILL) } }
|
||||
}
|
||||
|
||||
fun alive(pid: Int) = pid > 0 && File("/proc/$pid").exists()
|
||||
|
||||
/** Processes whose command line contains [text], for ending a build the app did not start. */
|
||||
fun find(text: String): List<Int> = File("/proc").listFiles().orEmpty().mapNotNull { dir ->
|
||||
val pid = dir.name.toIntOrNull() ?: return@mapNotNull null
|
||||
if (pid == Process.myPid()) return@mapNotNull null
|
||||
val args = runCatching { File(dir, "cmdline").readBytes().toString(Charsets.UTF_8).replace('\u0000', ' ') }.getOrDefault("")
|
||||
pid.takeIf { args.contains(text) && owned(dir, Process.myUid()) }
|
||||
}
|
||||
|
||||
private fun owned(dir: File, uid: Int) = runCatching {
|
||||
File(dir, "status").useLines { lines -> lines.first { it.startsWith("Uid:") }.split(Regex("\\s+"))[1].toInt() == uid }
|
||||
}.getOrDefault(false)
|
||||
|
||||
/** `/proc/<pid>/stat`: the name in parentheses may hold spaces, so fields count from its end. */
|
||||
@VisibleForTesting
|
||||
internal fun parseStat(text: String): Stat {
|
||||
val pid = text.substringBefore(' ').toInt()
|
||||
val f = text.substring(text.lastIndexOf(')') + 2).split(' ')
|
||||
return Stat(pid, f[1].toInt(), f[11].toLong() + f[12].toLong(), f[19].toLong(), f[21].toLong())
|
||||
}
|
||||
|
||||
/** The pid of a [java.lang.Process] the app started. */
|
||||
fun pidOf(process: java.lang.Process): Int =
|
||||
runCatching { process.javaClass.getDeclaredField("pid").apply { isAccessible = true }.getInt(process) }.getOrNull()
|
||||
?: Regex("pid=(\\d+)").find(process.toString())?.groupValues?.get(1)?.toInt() ?: 0
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateMapOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import com.droiddeck.launcher.session.OrphanReaper
|
||||
import java.io.File
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* First-run setup for the agent, as steps with a check and an action each. The first three are
|
||||
* needed to talk to the agent; GitHub and the build tools are only needed to open pull requests
|
||||
* and to make Lab builds on the device.
|
||||
*/
|
||||
object AgentSetup {
|
||||
enum class Step(val required: Boolean) { CONNECTION(true), INSTALL(true), SIGN_IN(true), GITHUB(false), BUILD_TOOLS(false), PREPARE(false) }
|
||||
enum class Status { UNKNOWN, DONE, TODO, WORKING, FAILED }
|
||||
|
||||
val status = mutableStateMapOf<Step, Status>()
|
||||
/** The last line of output from the step that is running or just failed. */
|
||||
val detail = mutableStateMapOf<Step, String>()
|
||||
var runtimeInstalled by mutableStateOf(true)
|
||||
private set
|
||||
|
||||
val ready: Boolean get() = Step.entries.filter { it.required }.all { status[it] == Status.DONE }
|
||||
|
||||
/** A step's action is running; its result belongs to the harness it started for. */
|
||||
val busy: Boolean get() = status.values.any { it == Status.WORKING }
|
||||
|
||||
/** Set once the required steps have all passed, so the chat opens without waiting for the checks. */
|
||||
fun completed(context: Context) = AgentHost.prefs(context).getBoolean(completedKey(AgentHost.harness), false)
|
||||
|
||||
private fun completedKey(harness: AgentHarness) = "setup_completed_${harness.id}"
|
||||
|
||||
private val main = Handler(Looper.getMainLooper())
|
||||
private const val REPO = "https://github.com/Droid-Deck/DroidDeck.git"
|
||||
private const val CHECKOUT = "/root/DroidDeck"
|
||||
private val HELPERS = listOf("android-open", "dd-gh-login", "droiddeckctl")
|
||||
internal const val CTL = "/root/.local/share/droiddeck/ctl"
|
||||
private const val PROBE_TIMEOUT_S = 60L
|
||||
|
||||
fun check(context: Context) {
|
||||
val app = context.applicationContext
|
||||
runtimeInstalled = LinuxRuntime.isInstalled(app)
|
||||
if (!runtimeInstalled) return
|
||||
AgentHost.refresh(app)
|
||||
val harness = AgentHost.harness
|
||||
val probes = mutableListOf<Pair<Step, List<String>>>()
|
||||
for (step in Step.entries) if (status[step] != Status.WORKING) {
|
||||
when (step) {
|
||||
Step.INSTALL -> set(step, if (harness.files.all { AgentHost.guestFileExists(app, it) }) Status.DONE else Status.TODO)
|
||||
Step.BUILD_TOOLS -> set(step, if (buildToolsInstalled(app)) Status.DONE else Status.TODO)
|
||||
Step.PREPARE -> set(step, if (prepared(app)) Status.DONE else Status.TODO)
|
||||
// The install brings the userland's adb; until then the app's own pairing is all there is to check.
|
||||
Step.CONNECTION -> if (!AgentHost.guestFileExists(app, "/usr/bin/adb")) {
|
||||
detail.remove(step)
|
||||
Thread({
|
||||
val live = com.droiddeck.launcher.core.WirelessAdbFix.liveConnectAddress(app) != null
|
||||
set(step, if (live) Status.DONE else Status.TODO)
|
||||
}, "agent-connection").start()
|
||||
} else probes += step to listOf("sh", "-c",
|
||||
"for i in 1 2 3; do adb connect \"\$ADB_SERIAL\" >/dev/null 2>&1; " +
|
||||
"state=\$(adb -s \"\$ADB_SERIAL\" get-state 2>&1); echo \"\$state\"; [ \"\$state\" = device ] && exit 0; sleep 1; done; exit 1")
|
||||
Step.SIGN_IN -> if (AgentHost.guestFileExists(app, harness.binary)) probes += step to harness.signedIn else set(step, Status.TODO)
|
||||
Step.GITHUB -> probes += step to listOf("gh", "auth", "status")
|
||||
}
|
||||
}
|
||||
Thread({ for ((step, command) in probes) probe(app, harness, step, command) }, "agent-checks").start()
|
||||
}
|
||||
|
||||
fun runsAsRoot(step: Step) = step == Step.INSTALL
|
||||
|
||||
/** Runs [step]'s action. [CONNECTION] is the app's own pairing flow, so the caller opens it. */
|
||||
fun run(context: Context, step: Step) {
|
||||
val app = context.applicationContext
|
||||
val harness = AgentHost.harness
|
||||
val command = when (step) {
|
||||
Step.CONNECTION -> return
|
||||
Step.INSTALL -> {
|
||||
listOf("sh", "-c", "set -e; export DEBIAN_FRONTEND=noninteractive; " +
|
||||
"dpkg --configure -a; apt-get update || echo 'Some package sources could not be refreshed; continuing'; apt-get -f install -y; " +
|
||||
"apt-get install -y --no-install-recommends git gh adb curl ca-certificates python3; ${harness.install}")
|
||||
}
|
||||
Step.SIGN_IN -> harness.signIn
|
||||
Step.GITHUB -> listOf("dd-gh-login")
|
||||
Step.BUILD_TOOLS -> listOf("sh", "-c", "set -e; [ -d $CHECKOUT/.git ] || git clone --filter=blob:none $REPO $CHECKOUT; " +
|
||||
"cd $CHECKOUT; [ -x tools/agent/setup ] || { echo 'This DroidDeck version has no tools/agent/setup yet'; exit 1; }; tools/agent/setup")
|
||||
Step.PREPARE -> listOf("sh", "-c", "cd $CHECKOUT && DD_LAB_DETACHED=1 dd-lab-build --prepare")
|
||||
}
|
||||
set(step, Status.WORKING)
|
||||
detail.remove(step)
|
||||
AgentHostService.setupStarted(app)
|
||||
Thread({
|
||||
val result = runCatching {
|
||||
installHelpers(app)
|
||||
runCatching { harness.prepare(LinuxRuntime.rootDir(app)) }
|
||||
val child = AgentHost.guest(app, command, fakeRoot = runsAsRoot(step)).start()
|
||||
val pid = AgentProcesses.pidOf(child)
|
||||
OrphanReaper.keep(pid)
|
||||
try {
|
||||
child.outputStream.close()
|
||||
logFile(app, step).apply { parentFile?.mkdirs() }.bufferedWriter().use { log ->
|
||||
child.inputStream.bufferedReader().forEachLine { line ->
|
||||
log.appendLine(line)
|
||||
val text = line.trim()
|
||||
if (text.isNotEmpty() && !noise(text)) main.post {
|
||||
detail[step] = text.take(160)
|
||||
if (step == Step.GITHUB && text.startsWith("GitHub device code:")) AgentHostService.update(app)
|
||||
}
|
||||
}
|
||||
child.waitFor().also { log.appendLine("exit $it") }
|
||||
}
|
||||
} finally {
|
||||
OrphanReaper.release(pid)
|
||||
}
|
||||
}
|
||||
main.post {
|
||||
AgentHostService.setupEnded(app)
|
||||
if (result.getOrNull() == 0) {
|
||||
detail.remove(step)
|
||||
status[step] = Status.UNKNOWN
|
||||
check(app)
|
||||
} else {
|
||||
status[step] = Status.FAILED
|
||||
if (result.isFailure) detail[step] = result.exceptionOrNull()?.message ?: "failed"
|
||||
}
|
||||
}
|
||||
}, "agent-setup-${step.name.lowercase()}").start()
|
||||
}
|
||||
|
||||
/** The whole output of a step's last run; the card shows only its last line. */
|
||||
fun logFile(app: Context, step: Step) = File(app.filesDir, "agent/setup-${step.name.lowercase()}.log")
|
||||
|
||||
fun buildToolsInstalled(app: Context) = AgentHost.guestFileExists(app, "/root/aapt2/aapt2") && AgentHost.guestFileExists(app, "$CHECKOUT/.git")
|
||||
|
||||
/** dd-lab-build compiled this install's commit, so a Lab build compiles only what changed. */
|
||||
private fun prepared(app: Context) = runCatching {
|
||||
File(LinuxRuntime.rootDir(app), "root/.cache/dd-lab-build-base").readText().trim()
|
||||
.startsWith(com.droiddeck.launcher.lab.LabOverlay.apkCommit.take(7))
|
||||
}.getOrDefault(false)
|
||||
|
||||
/** Drops what the checks found, which belonged to the previous harness. */
|
||||
fun forget() {
|
||||
status.clear()
|
||||
detail.clear()
|
||||
}
|
||||
|
||||
private fun probe(app: Context, harness: AgentHarness, step: Step, command: List<String>) {
|
||||
var output = ""
|
||||
val ok = runCatching {
|
||||
val child = AgentHost.guest(app, command, connectAdb = step == Step.CONNECTION).start()
|
||||
child.outputStream.close()
|
||||
val reader = Thread({ output = child.inputStream.bufferedReader().readText() }, "agent-check-output").apply { isDaemon = true; start() }
|
||||
val exited = child.waitFor(PROBE_TIMEOUT_S, TimeUnit.SECONDS)
|
||||
if (!exited) {
|
||||
AgentProcesses.killTree(AgentProcesses.pidOf(child))
|
||||
child.destroyForcibly()
|
||||
}
|
||||
reader.join(2_000)
|
||||
exited && child.exitValue() == 0
|
||||
}.onFailure { output = it.message.orEmpty() }.getOrDefault(false)
|
||||
main.post {
|
||||
if (AgentHost.harness != harness) return@post
|
||||
if (status[step] != Status.WORKING) status[step] = if (ok) Status.DONE else Status.TODO
|
||||
val last = output.lines().lastOrNull { it.isNotBlank() && !noise(it.trim()) }?.trim()?.take(160)
|
||||
when {
|
||||
ok -> detail.remove(step)
|
||||
step == Step.CONNECTION -> detail[step] = app.getString(com.droiddeck.launcher.R.string.agent_connection_off)
|
||||
step.required && last != null -> detail[step] = last
|
||||
}
|
||||
if (ready) AgentHost.prefs(app).edit().putBoolean(completedKey(harness), true).apply()
|
||||
}
|
||||
}
|
||||
|
||||
/** proot warns about its bindings on every start; that says nothing about the step. */
|
||||
private fun noise(line: String) = line.startsWith("proot warning")
|
||||
|
||||
private fun set(step: Step, value: Status) {
|
||||
if (Looper.myLooper() == Looper.getMainLooper()) status[step] = value else main.post { status[step] = value }
|
||||
}
|
||||
|
||||
/** Written before every step, so the helpers a step relies on are there and match this DroidDeck version. */
|
||||
internal fun installHelpers(app: Context) {
|
||||
val root = LinuxRuntime.rootDir(app)
|
||||
val bin = File(root, "root/.local/bin").apply { mkdirs() }
|
||||
for (name in HELPERS) copyAsset(app, "agent/$name", File(bin, name))
|
||||
val ctl = File(root, CTL.removePrefix("/")).apply { mkdirs() }
|
||||
for (name in app.assets.list("agent/ctl").orEmpty()) copyAsset(app, "agent/ctl/$name", File(ctl, name))
|
||||
unpinAdbSerial(File(root, "root/.bashrc"))
|
||||
}
|
||||
|
||||
/** Older tools/agent/setup pinned the adb port in .bashrc, which overrides the live port DroidDeck passes. */
|
||||
internal fun unpinAdbSerial(bashrc: File) {
|
||||
val text = runCatching { bashrc.readText() }.getOrNull() ?: return
|
||||
val fixed = text.replace("ADB_SERIAL=127.0.0.1:5555 ", "ADB_SERIAL=\"\${ADB_SERIAL:-127.0.0.1:5555}\" ")
|
||||
if (fixed != text) runCatching { bashrc.writeText(fixed) }
|
||||
}
|
||||
|
||||
private fun copyAsset(app: Context, asset: String, target: File) {
|
||||
app.assets.open(asset).use { input -> target.outputStream().use { input.copyTo(it) } }
|
||||
target.setExecutable(true, false)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import androidx.compose.runtime.mutableStateMapOf
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import java.io.File
|
||||
import java.io.IOException
|
||||
import java.nio.file.FileVisitResult
|
||||
import java.nio.file.Files
|
||||
import java.nio.file.Path
|
||||
import java.nio.file.SimpleFileVisitor
|
||||
import java.nio.file.attribute.BasicFileAttributes
|
||||
|
||||
/**
|
||||
* What the agent adds to the Linux userland, measured and removable piece by piece. Sign-ins
|
||||
* (~/.claude, ~/.codex, gh's config) are left alone, so removing a CLI and installing it again
|
||||
* does not sign out.
|
||||
*/
|
||||
object AgentStorage {
|
||||
enum class Item(val paths: List<String>) {
|
||||
CLAUDE_CODE(listOf("/root/.local/share/claude", "/root/.local/bin/claude", "/root/cc")),
|
||||
CODEX(listOf("/root/.local/bin/codex", "/root/.local/bin/codex-code-mode-host")),
|
||||
BUILD_TOOLS(listOf("/root/android-sdk", "/root/aapt2", "/root/x86root", "/root/.gradle")),
|
||||
SOURCE(listOf("/root/DroidDeck")),
|
||||
CACHES(listOf("/root/.cache", "/root/.npm")),
|
||||
}
|
||||
|
||||
/** Bytes per item; missing while it is being measured. */
|
||||
val sizes = mutableStateMapOf<Item, Long>()
|
||||
val removing = mutableStateMapOf<Item, Boolean>()
|
||||
|
||||
private val main = Handler(Looper.getMainLooper())
|
||||
|
||||
fun measure(context: Context) {
|
||||
val root = LinuxRuntime.rootDir(context.applicationContext)
|
||||
Thread({
|
||||
for (item in Item.entries) {
|
||||
val bytes = item.paths.sumOf { size(File(root, it.removePrefix("/")).toPath()) }
|
||||
main.post { sizes[item] = bytes }
|
||||
}
|
||||
}, "agent-storage").start()
|
||||
}
|
||||
|
||||
fun remove(context: Context, item: Item) {
|
||||
val app = context.applicationContext
|
||||
val root = LinuxRuntime.rootDir(app)
|
||||
removing[item] = true
|
||||
Thread({
|
||||
for (path in item.paths) runCatching { delete(File(root, path.removePrefix("/")).toPath()) }
|
||||
main.post {
|
||||
removing.remove(item)
|
||||
AgentHost.refresh(app)
|
||||
AgentSetup.check(app)
|
||||
measure(app)
|
||||
}
|
||||
}, "agent-storage-remove").start()
|
||||
}
|
||||
|
||||
/** Walks without following links, so a link out of the rootfs (into /sdcard, say) counts and removes only itself. */
|
||||
@VisibleForTesting
|
||||
internal fun size(path: Path): Long {
|
||||
if (!Files.exists(path, java.nio.file.LinkOption.NOFOLLOW_LINKS)) return 0
|
||||
var total = 0L
|
||||
Files.walkFileTree(path, object : SimpleFileVisitor<Path>() {
|
||||
override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
|
||||
total += attrs.size()
|
||||
return FileVisitResult.CONTINUE
|
||||
}
|
||||
override fun visitFileFailed(file: Path, exc: IOException) = FileVisitResult.CONTINUE
|
||||
})
|
||||
return total
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun delete(path: Path) {
|
||||
if (!Files.exists(path, java.nio.file.LinkOption.NOFOLLOW_LINKS)) return
|
||||
Files.walkFileTree(path, object : SimpleFileVisitor<Path>() {
|
||||
override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
|
||||
Files.deleteIfExists(file)
|
||||
return FileVisitResult.CONTINUE
|
||||
}
|
||||
override fun postVisitDirectory(dir: Path, exc: IOException?): FileVisitResult {
|
||||
Files.deleteIfExists(dir)
|
||||
return FileVisitResult.CONTINUE
|
||||
}
|
||||
override fun visitFileFailed(file: Path, exc: IOException): FileVisitResult {
|
||||
runCatching { Files.deleteIfExists(file) }
|
||||
return FileVisitResult.CONTINUE
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
|
||||
object AgentTab {
|
||||
var shown by mutableStateOf(true)
|
||||
private set
|
||||
|
||||
val visible: Boolean get() = shown && AgentHost.available
|
||||
|
||||
fun load(context: Context) {
|
||||
shown = SessionPrefs.agentTab(context)
|
||||
}
|
||||
|
||||
fun set(context: Context, show: Boolean) {
|
||||
shown = show
|
||||
SessionPrefs.setAgentTab(context, show)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import android.content.Context
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import java.io.File
|
||||
import java.nio.file.FileVisitResult
|
||||
import java.nio.file.Files
|
||||
import java.nio.file.LinkOption
|
||||
import java.nio.file.Path
|
||||
import java.nio.file.SimpleFileVisitor
|
||||
import java.nio.file.attribute.BasicFileAttributes
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/** Claude Code's MCP servers and skills in the userland, through its own CLI and skills folder. */
|
||||
internal object AgentTools {
|
||||
data class Server(val name: String, val target: String, val status: String) {
|
||||
/** Connectors come from the claude.ai account and are managed there, not by the CLI. */
|
||||
val account get() = name.startsWith("claude.ai ")
|
||||
}
|
||||
|
||||
data class Skill(val name: String, val description: String)
|
||||
|
||||
class Result(val ok: Boolean, val output: String)
|
||||
|
||||
private const val SKILLS = "root/.claude/skills"
|
||||
private val SERVER = Regex("""^(.+?): (.+) - (.+)$""")
|
||||
|
||||
fun servers(context: Context): List<Server>? {
|
||||
val result = run(context, listOf(ClaudeCode.binary, "mcp", "list"))
|
||||
if (!result.ok) return null
|
||||
return parseServers(result.output)
|
||||
}
|
||||
|
||||
internal fun parseServers(output: String): List<Server> = output.lines().mapNotNull { line ->
|
||||
SERVER.find(line.trim())?.destructured?.let { (name, target, status) -> Server(name, target, status) }
|
||||
}
|
||||
|
||||
/** A URL is added as an HTTP server; anything else is the command that starts a stdio server. */
|
||||
internal fun addCommand(name: String, target: String): List<String> {
|
||||
val t = target.trim()
|
||||
val base = listOf(ClaudeCode.binary, "mcp", "add", "--scope", "user")
|
||||
return if (t.startsWith("http://") || t.startsWith("https://")) base + listOf("--transport", "http", name.trim(), t)
|
||||
else base + listOf(name.trim(), "--") + words(t)
|
||||
}
|
||||
|
||||
/** Splits a command line the way a shell would for quotes and backslashes, without expanding anything. */
|
||||
internal fun words(line: String): List<String> {
|
||||
val words = mutableListOf<String>()
|
||||
val word = StringBuilder()
|
||||
var inWord = false
|
||||
var quote: Char? = null
|
||||
var i = 0
|
||||
while (i < line.length) {
|
||||
val c = line[i]
|
||||
when {
|
||||
quote == '\'' -> if (c == '\'') quote = null else word.append(c)
|
||||
c == '\\' && i + 1 < line.length && (quote == null || line[i + 1] == '"' || line[i + 1] == '\\') -> {
|
||||
word.append(line[++i])
|
||||
inWord = true
|
||||
}
|
||||
quote == '"' -> if (c == '"') quote = null else word.append(c)
|
||||
c == '\'' || c == '"' -> {
|
||||
quote = c
|
||||
inWord = true
|
||||
}
|
||||
c.isWhitespace() -> if (inWord) {
|
||||
words += word.toString()
|
||||
word.clear()
|
||||
inWord = false
|
||||
}
|
||||
else -> {
|
||||
word.append(c)
|
||||
inWord = true
|
||||
}
|
||||
}
|
||||
i++
|
||||
}
|
||||
if (inWord) words += word.toString()
|
||||
return words
|
||||
}
|
||||
|
||||
fun add(context: Context, name: String, target: String) = run(context, addCommand(name, target))
|
||||
|
||||
fun remove(context: Context, name: String) = run(context, listOf(ClaudeCode.binary, "mcp", "remove", name))
|
||||
|
||||
fun skills(context: Context): List<Skill> =
|
||||
File(LinuxRuntime.rootDir(context), SKILLS).listFiles { f -> f.isDirectory }.orEmpty().sortedBy { it.name.lowercase() }.map { dir ->
|
||||
Skill(dir.name, description(File(dir, "SKILL.md")))
|
||||
}
|
||||
|
||||
internal fun description(file: File): String = runCatching {
|
||||
val lines = file.readLines()
|
||||
if (lines.firstOrNull()?.trim() != "---") return@runCatching ""
|
||||
lines.drop(1).takeWhile { it.trim() != "---" }.firstOrNull { it.startsWith("description:") }
|
||||
?.removePrefix("description:")?.trim()?.trim('"', '\'').orEmpty()
|
||||
}.getOrDefault("")
|
||||
|
||||
fun deleteSkill(context: Context, name: String): Boolean {
|
||||
if (name.isEmpty() || name.contains('/') || name.startsWith(".")) return false
|
||||
val root = File(LinuxRuntime.rootDir(context), SKILLS)
|
||||
val dir = File(root, name)
|
||||
if (dir.parentFile?.path != root.path) return false
|
||||
return deleteTree(dir.toPath())
|
||||
}
|
||||
|
||||
/** Deletes [path] and what is under it; a symbolic link is removed itself, never what it points to. */
|
||||
internal fun deleteTree(path: Path): Boolean = runCatching {
|
||||
if (!Files.exists(path, LinkOption.NOFOLLOW_LINKS)) return@runCatching true
|
||||
Files.walkFileTree(path, object : SimpleFileVisitor<Path>() {
|
||||
override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
|
||||
Files.delete(file)
|
||||
return FileVisitResult.CONTINUE
|
||||
}
|
||||
|
||||
override fun postVisitDirectory(dir: Path, exc: java.io.IOException?): FileVisitResult {
|
||||
if (exc != null) throw exc
|
||||
Files.delete(dir)
|
||||
return FileVisitResult.CONTINUE
|
||||
}
|
||||
})
|
||||
true
|
||||
}.getOrDefault(false)
|
||||
|
||||
private fun run(context: Context, command: List<String>): Result {
|
||||
val child = runCatching { AgentHost.guest(context.applicationContext, command, connectAdb = false).start() }
|
||||
.getOrElse { return Result(false, it.message.orEmpty()) }
|
||||
val output = StringBuffer()
|
||||
// The CLI can hold its output open past the deadline, so it is read beside the wait rather than before it.
|
||||
val reader = Thread({ runCatching { child.inputStream.bufferedReader().forEachLine { output.append(it).append('\n') } } }, "agent-tools").apply { start() }
|
||||
return try {
|
||||
val ended = child.waitFor(90, TimeUnit.SECONDS)
|
||||
if (!ended) child.destroyForcibly()
|
||||
reader.join(2_000)
|
||||
Result(ended && child.exitValue() == 0, output.toString().trim())
|
||||
} catch (e: InterruptedException) {
|
||||
child.destroyForcibly()
|
||||
Thread.currentThread().interrupt()
|
||||
Result(false, output.toString().trim())
|
||||
} finally {
|
||||
runCatching { child.inputStream.close() }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package com.droiddeck.launcher.agent
|
||||
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
|
||||
/** A Lab build in progress, as dd-lab-build reports it in `~/.cache/dd-lab-build.json`. */
|
||||
data class LabProgress(
|
||||
val stage: String, val prepare: Boolean, val permille: Int, val task: String,
|
||||
val done: Int, val total: Int, val etaSeconds: Int, val elapsedSeconds: Int, val pid: Int,
|
||||
) {
|
||||
val running get() = stage in RUNNING
|
||||
val failed get() = stage == "failed"
|
||||
|
||||
companion object {
|
||||
private val RUNNING = setOf("checking", "fetching", "sdk", "planning", "building", "packaging", "restarting")
|
||||
private const val PATH = "root/.cache/dd-lab-build.json"
|
||||
/** A finished build stays on screen this long. */
|
||||
private const val SHOW_DONE_MS = 60_000L
|
||||
|
||||
/** The build, while it runs and shortly after; null when there is none to show. */
|
||||
fun read(rootfs: File): LabProgress? {
|
||||
val file = File(rootfs, PATH)
|
||||
if (!file.isFile) return null
|
||||
val parsed = parse(runCatching { file.readText() }.getOrNull() ?: return null) ?: return null
|
||||
val progress = when {
|
||||
!parsed.running || AgentProcesses.alive(parsed.pid) -> parsed
|
||||
// The restart ends the app and the script with it, so a restart that got that far succeeded.
|
||||
parsed.stage == "restarting" -> parsed.copy(stage = "ready")
|
||||
else -> parsed.copy(stage = "failed", task = "stopped")
|
||||
}
|
||||
return progress.takeIf { it.running || System.currentTimeMillis() - file.lastModified() < SHOW_DONE_MS }
|
||||
}
|
||||
|
||||
/** Ends the build and Gradle's daemon, which keeps compiling after its client is gone. */
|
||||
fun cancel(rootfs: File, progress: LabProgress) {
|
||||
AgentProcesses.killTree(progress.pid)
|
||||
AgentProcesses.find("GradleDaemon").forEach(AgentProcesses::killTree)
|
||||
runCatching {
|
||||
File(rootfs, PATH).writeText(JSONObject().put("stage", "failed").put("task", "stopped").put("pid", 0).toString())
|
||||
}
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun parse(json: String): LabProgress? = runCatching {
|
||||
val o = JSONObject(json)
|
||||
LabProgress(
|
||||
o.getString("stage"), o.optString("mode") == "prepare", o.optInt("permille"), o.optString("task"),
|
||||
o.optInt("done"), o.optInt("total"), o.optInt("eta", -1), o.optInt("elapsed"), o.optInt("pid"),
|
||||
)
|
||||
}.getOrNull()
|
||||
}
|
||||
}
|
||||
@@ -16,6 +16,8 @@ import java.nio.file.Files;
|
||||
import java.nio.file.StandardCopyOption;
|
||||
import java.util.ArrayList;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.function.IntConsumer;
|
||||
import java.util.function.IntSupplier;
|
||||
|
||||
public class PulseAudioComponent extends SessionPart {
|
||||
private static final String TAG = "PulseAudio";
|
||||
@@ -29,7 +31,55 @@ public class PulseAudioComponent extends SessionPart {
|
||||
private final File deviceControls;
|
||||
private File logFile;
|
||||
private final String micFifoPath;
|
||||
private volatile int pid = -1;
|
||||
private final HostLifecycle host = new HostLifecycle(Process::killProcess);
|
||||
|
||||
static final class HostLifecycle {
|
||||
volatile int pid = -1;
|
||||
private long generation;
|
||||
private long launches;
|
||||
private final IntConsumer terminate;
|
||||
|
||||
HostLifecycle(IntConsumer terminate) {
|
||||
this.terminate = terminate;
|
||||
}
|
||||
|
||||
synchronized long begin() {
|
||||
stop();
|
||||
return generation;
|
||||
}
|
||||
|
||||
synchronized void stop() {
|
||||
generation++;
|
||||
if (pid > 1) terminate.accept(pid);
|
||||
pid = -1;
|
||||
}
|
||||
|
||||
synchronized boolean launch(long expected, IntSupplier launch) {
|
||||
if (expected != generation) return false;
|
||||
launches++;
|
||||
pid = launch.getAsInt();
|
||||
return true;
|
||||
}
|
||||
|
||||
synchronized boolean current(long expected) {
|
||||
return expected == generation;
|
||||
}
|
||||
|
||||
/** The latest launch; a sink guard holds it so it never reconfigures a host started after its own. */
|
||||
synchronized long token() {
|
||||
return launches;
|
||||
}
|
||||
|
||||
synchronized boolean live(long token) {
|
||||
return token == launches && pid > 1;
|
||||
}
|
||||
|
||||
synchronized boolean exited(long expected) {
|
||||
if (expected != generation || pid <= 1) return false;
|
||||
pid = -1;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public PulseAudioComponent(Context context) {
|
||||
this(context, null);
|
||||
@@ -64,7 +114,12 @@ public class PulseAudioComponent extends SessionPart {
|
||||
|
||||
@Override
|
||||
public void start() {
|
||||
stop();
|
||||
start(host.begin());
|
||||
}
|
||||
|
||||
private synchronized void start(long generation) {
|
||||
// An exit callback's restart can be overtaken by a newer start; it must not touch the newer host's socket.
|
||||
if (!host.current(generation)) return;
|
||||
if (!workingDir.isDirectory()) {
|
||||
workingDir.mkdirs();
|
||||
FileUtils.chmod(workingDir, 0771);
|
||||
@@ -118,17 +173,23 @@ public class PulseAudioComponent extends SessionPart {
|
||||
+ " -n --file=default.pa --daemonize=false --use-pid-file=false --exit-idle-time=-1"
|
||||
+ " --log-level=info";
|
||||
final java.io.PrintWriter out = openLog();
|
||||
pid = HostProcess.start(command, env.toArray(new String[0]), workingDir, null,
|
||||
if (!host.launch(generation, () -> HostProcess.start(command, env.toArray(new String[0]), workingDir, status -> {
|
||||
if (host.exited(generation)) {
|
||||
Log.w(TAG, "audio host exited with status " + status + "; restarting");
|
||||
start(generation);
|
||||
}
|
||||
},
|
||||
line -> {
|
||||
Log.i(TAG, line);
|
||||
if (out != null) synchronized (out) { out.println(line); out.flush(); }
|
||||
});
|
||||
Thread guard = new Thread(() -> ensureClientSink(out), "pulse-sink-guard");
|
||||
}))) return;
|
||||
long token = host.token();
|
||||
Thread guard = new Thread(() -> ensureClientSink(out, token), "pulse-sink-guard");
|
||||
guard.setDaemon(true);
|
||||
guard.start();
|
||||
}
|
||||
|
||||
private void ensureClientSink(java.io.PrintWriter out) {
|
||||
private void ensureClientSink(java.io.PrintWriter out, long token) {
|
||||
try {
|
||||
// Nothing that may block (a sink whose AAudio open hangs: a Galaxy S24 FE (US) hung the
|
||||
// daemon's start-up loading one from default.pa) is loaded by the daemon itself; the
|
||||
@@ -137,14 +198,14 @@ public class PulseAudioComponent extends SessionPart {
|
||||
long deadline = started + 30000L;
|
||||
String sinks = null;
|
||||
boolean socketSeen = false;
|
||||
while (System.currentTimeMillis() < deadline && pid > 1) {
|
||||
while (System.currentTimeMillis() < deadline && host.live(token)) {
|
||||
socketSeen |= socket().exists();
|
||||
if (socketSeen && (sinks = pactl("list", "short", "sinks")) != null) break;
|
||||
if (socketSeen && (sinks = pactlFor(token, "list", "short", "sinks")) != null) break;
|
||||
try { Thread.sleep(250L); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; }
|
||||
}
|
||||
note(out, "client sink: daemon " + (sinks != null ? "answered" : "did not answer") + " after "
|
||||
+ (System.currentTimeMillis() - started) + " ms (socket " + (socketSeen ? "present" : "never appeared") + ", pactl "
|
||||
+ (new File(workingDir, "pactl").isFile() ? "present" : "MISSING") + ", daemon pid " + pid + ")");
|
||||
+ (new File(workingDir, "pactl").isFile() ? "present" : "MISSING") + ", daemon pid " + host.pid + ")");
|
||||
String line;
|
||||
if (sinks == null) {
|
||||
line = "== client sink: the daemon did not answer in 30 s; no fallback attempted";
|
||||
@@ -155,15 +216,15 @@ public class PulseAudioComponent extends SessionPart {
|
||||
// still switching the output route as the session starts (seen on a Galaxy S24 FE):
|
||||
// try DirectAudio again, then the plain sink, a few times over ten seconds.
|
||||
String loadedAs = null;
|
||||
for (int attempt = 1; attempt <= 5 && loadedAs == null && pid > 1; attempt++) {
|
||||
for (int attempt = 1; attempt <= 5 && loadedAs == null && host.live(token); attempt++) {
|
||||
try { Thread.sleep(2000L); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; }
|
||||
if (pactl("load-module", "module-directaudio-native-sink", "sink_name=DirectAudio", "performance_mode=1",
|
||||
if (pactlFor(token, "load-module", "module-directaudio-native-sink", "sink_name=DirectAudio", "performance_mode=1",
|
||||
"adaptive=1", "decay=0", "limiter=1", "watchdog=1", "volume=1.0", "control_dir=" + deviceControls) != null
|
||||
&& pactl("set-default-sink", "DirectAudio") != null) {
|
||||
&& pactlFor(token, "set-default-sink", "DirectAudio") != null) {
|
||||
loadedAs = "DirectAudio on attempt " + attempt;
|
||||
} else if (pactl("load-module", "module-aaudio-sink", "sink_name=AAudioSink",
|
||||
} else if (pactlFor(token, "load-module", "module-aaudio-sink", "sink_name=AAudioSink",
|
||||
"performance_mode=" + (attempt == 1 ? "1" : "0"), "adaptive=1", "volume=1.0", "control_dir=" + deviceControls) != null
|
||||
&& pactl("set-default-sink", "AAudioSink") != null) {
|
||||
&& pactlFor(token, "set-default-sink", "AAudioSink") != null) {
|
||||
loadedAs = "the plain AAudio sink (AAudioSink) on attempt " + attempt;
|
||||
}
|
||||
}
|
||||
@@ -186,10 +247,14 @@ public class PulseAudioComponent extends SessionPart {
|
||||
if (out != null) synchronized (out) { out.println(line); out.flush(); }
|
||||
}
|
||||
|
||||
private String pactlFor(long token, String... args) {
|
||||
return host.live(token) ? pactl(args) : null;
|
||||
}
|
||||
|
||||
/** Runs pactl against this daemon; its stdout, or null when it failed or timed out. */
|
||||
private String pactl(String... args) {
|
||||
File pactl = new File(workingDir, "pactl");
|
||||
if (!pactl.isFile() || pid <= 1) return null;
|
||||
if (!pactl.isFile() || host.pid <= 1) return null;
|
||||
java.lang.Process process = null;
|
||||
try {
|
||||
File modules = new File(workingDir, "modules/arm64");
|
||||
@@ -231,10 +296,7 @@ public class PulseAudioComponent extends SessionPart {
|
||||
|
||||
@Override
|
||||
public void stop() {
|
||||
if (pid != -1) {
|
||||
Process.killProcess(pid);
|
||||
pid = -1;
|
||||
}
|
||||
host.stop();
|
||||
}
|
||||
|
||||
public boolean setSinkSuspended(boolean suspended) {
|
||||
@@ -247,7 +309,7 @@ public class PulseAudioComponent extends SessionPart {
|
||||
|
||||
private boolean suspend(String kind, String name, boolean suspended) {
|
||||
File pactl = new File(workingDir, "pactl");
|
||||
if (!pactl.isFile() || pid <= 1) {
|
||||
if (!pactl.isFile() || host.pid <= 1) {
|
||||
Log.w(TAG, "cannot change " + kind + " state: PulseAudio control client or server unavailable");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@ package com.droiddeck.launcher.core
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.BuildConfig
|
||||
import com.droiddeck.launcher.lab.LabOverlay
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
@@ -16,6 +17,7 @@ import java.io.FileInputStream
|
||||
internal class AddonPack(
|
||||
val name: String, private val sha256: String, val size: Long, private val required: List<String>,
|
||||
private val reuseDeviceCopy: Boolean = sha256.isEmpty() && !BuildConfig.CI_BUILD,
|
||||
private val labBuild: Boolean = LabOverlay.active != null,
|
||||
private val bundle: (Context) -> java.io.InputStream = { it.assets.open("packs/$name.tar.zst") },
|
||||
) {
|
||||
sealed interface State {
|
||||
@@ -29,6 +31,9 @@ internal class AddonPack(
|
||||
val state: StateFlow<State> = mutableState.asStateFlow()
|
||||
private val lock = Any()
|
||||
|
||||
@Volatile var failure: String? = null
|
||||
private set
|
||||
|
||||
val available: Boolean get() = sha256.isNotEmpty()
|
||||
private val tag get() = "pack-$name-${sha256.take(16)}"
|
||||
private val urls get() = listOfNotNull(
|
||||
@@ -42,7 +47,8 @@ internal class AddonPack(
|
||||
|
||||
fun installed(context: Context): Boolean = version(context).isNotEmpty() && File(dir(context), COMPLETE).isFile
|
||||
|
||||
private fun version(context: Context): String = if (!reuseDeviceCopy) sha256 else deviceCopy(context).orEmpty()
|
||||
private fun version(context: Context): String =
|
||||
if (reuseDeviceCopy || labBuild) deviceCopy(context) ?: sha256 else sha256
|
||||
|
||||
private fun deviceCopy(context: Context): String? = root(context).listFiles().orEmpty()
|
||||
.filter { dir ->
|
||||
@@ -64,9 +70,13 @@ internal class AddonPack(
|
||||
if (installed(app)) { mutableState.value = State.Ready; return }
|
||||
if (mutableState.value is State.Downloading) return
|
||||
mutableState.value = State.Downloading(0f)
|
||||
failure = null
|
||||
}
|
||||
scope.launch {
|
||||
val ok = runCatching { install(app) }.onFailure { Log.w(TAG, "$name: install failed", it) }.getOrDefault(false)
|
||||
val ok = runCatching { install(app) }.onFailure {
|
||||
Log.w(TAG, "$name: install failed", it)
|
||||
failure = it.toString()
|
||||
}.getOrDefault(false)
|
||||
mutableState.value = if (ok) State.Ready else State.Failed
|
||||
if (ok) onReady(app)
|
||||
}
|
||||
@@ -90,20 +100,28 @@ internal class AddonPack(
|
||||
|
||||
private fun install(context: Context): Boolean {
|
||||
if (!available) {
|
||||
Log.w(TAG, if (reuseDeviceCopy) "$name: this build has no pack and none is installed" else "$name: this build has no pack")
|
||||
failure = if (reuseDeviceCopy) "this build has no pack and none is installed" else "this build has no pack"
|
||||
Log.w(TAG, "$name: $failure")
|
||||
return false
|
||||
}
|
||||
val root = root(context).apply { mkdirs() }
|
||||
val archive = File(root, "$sha256.tar.zst")
|
||||
val problems = mutableListOf<String>()
|
||||
val downloaded = bundled(context, archive) || urls.any { url ->
|
||||
Downloader.downloadFile(url, archive, true, sha256) { p -> mutableState.value = State.Downloading(p.coerceIn(0f, 1f)) }
|
||||
.also { if (!it) archive.delete() }
|
||||
.also { if (!it) { archive.delete(); Downloader.lastFailure()?.let(problems::add) } }
|
||||
}
|
||||
if (!downloaded) {
|
||||
failure = problems.joinToString("; ").ifEmpty { "download failed" }
|
||||
return false
|
||||
}
|
||||
if (!downloaded) return false
|
||||
val staging = File(root, "$sha256.partial")
|
||||
staging.deleteRecursively()
|
||||
try {
|
||||
if (!FileInputStream(archive).use { TarZst.extract(it, staging) }) return false
|
||||
if (!FileInputStream(archive).use { TarZst.extract(it, staging) }) {
|
||||
failure = "could not unpack the pack"
|
||||
return false
|
||||
}
|
||||
check(required.all { File(staging, it).isFile }) { "$name pack is incomplete" }
|
||||
File(staging, COMPLETE).writeText(sha256)
|
||||
val target = dir(context)
|
||||
@@ -154,5 +172,8 @@ internal class AddonPack(
|
||||
listOf("runtime.tzst", "version.txt"))
|
||||
val UBISOFT = AddonPack("ubisoft", BuildConfig.PACK_UBISOFT_SHA256, BuildConfig.PACK_UBISOFT_SIZE,
|
||||
listOf("droiddeck-upc.exe"))
|
||||
val ROCKSTAR = AddonPack("rockstar", BuildConfig.PACK_ROCKSTAR_SHA256, BuildConfig.PACK_ROCKSTAR_SIZE,
|
||||
listOf("Launcher32.exe", "Launcher64.exe"))
|
||||
val DIRT = AddonPack("dirt", BuildConfig.PACK_DIRT_SHA256, BuildConfig.PACK_DIRT_SIZE, listOf("ws2_32.dll"))
|
||||
}
|
||||
}
|
||||
@@ -27,6 +27,32 @@ object AppUiPrefs {
|
||||
context.getSharedPreferences("app-ui", Context.MODE_PRIVATE).edit().putInt("orientation", value).apply()
|
||||
}
|
||||
|
||||
const val HOME_PAGE_STEAM = "steam"
|
||||
const val HOME_PAGE_APPS = "android-apps"
|
||||
|
||||
val homePageOptions = listOf(
|
||||
HOME_PAGE_STEAM to R.string.rail_steam,
|
||||
HOME_PAGE_APPS to R.string.content_android_apps,
|
||||
)
|
||||
|
||||
fun homePage(context: Context): String =
|
||||
context.getSharedPreferences("app-ui", Context.MODE_PRIVATE)
|
||||
.getString("home-page", null)
|
||||
.takeIf { value -> homePageOptions.any { it.first == value } }
|
||||
?: HOME_PAGE_STEAM
|
||||
|
||||
fun setHomePage(context: Context, value: String) {
|
||||
require(homePageOptions.any { it.first == value })
|
||||
context.getSharedPreferences("app-ui", Context.MODE_PRIVATE).edit().putString("home-page", value).apply()
|
||||
}
|
||||
|
||||
fun hideHomeFromRecents(context: Context): Boolean =
|
||||
context.getSharedPreferences("app-ui", Context.MODE_PRIVATE).getBoolean("hide-home-from-recents", false)
|
||||
|
||||
fun setHideHomeFromRecents(context: Context, hidden: Boolean) {
|
||||
context.getSharedPreferences("app-ui", Context.MODE_PRIVATE).edit().putBoolean("hide-home-from-recents", hidden).apply()
|
||||
}
|
||||
|
||||
internal fun normalizeScale(percent: Int): Int = percent.takeIf { it in scales } ?: DEFAULT_SCALE
|
||||
|
||||
fun scale(context: Context): Int = normalizeScale(
|
||||
|
||||
@@ -233,6 +233,10 @@ object DeviceReport {
|
||||
else "${turnip.displayName(displayId)} ${turnip.driverVersion(displayId)}".trim()
|
||||
k("Display driver (chosen)", if (androidChoice.isEmpty()) "Auto -> $displayLabel" else androidChoice)
|
||||
k(" name / version", displayLabel)
|
||||
turnip.effectiveId().takeIf { it != displayId }?.let { used ->
|
||||
k(" in use", if (used == "system") DeviceInfo.builtinDriverLabel(SystemVulkanDriver.isPowerVr(), runtime = false)
|
||||
else "${turnip.displayName(used)} ${turnip.driverVersion(used)}".trim())
|
||||
}
|
||||
k(" imported available", turnip.enumerateImported().ifEmpty { listOf("none") }.joinToString(", "))
|
||||
val lm = LinuxVulkanDriverManager(context)
|
||||
run {
|
||||
@@ -242,7 +246,9 @@ object DeviceReport {
|
||||
lm.getMinGlibc(id).let { if (it.isEmpty()) "" else " (glibc $it+)" } +
|
||||
if (lm.isInstalled(id)) "" else if (SystemVulkanDriver.isPowerVr()) " [MISSING - select an installed driver or Auto]"
|
||||
else " [MISSING - falls back to the runtime's own]"
|
||||
k("Linux driver", label)
|
||||
val route = DeviceInfo.hostRoute(context)
|
||||
k("Linux driver", route ?: label)
|
||||
if (route != null) k(" chosen, not used", label)
|
||||
}
|
||||
k("Runtime's own ICD", LinuxRuntime.vulkanIcd(context)?.path)
|
||||
k("Mali (Venus)", if (com.droiddeck.launcher.session.VenusComponent.wanted(context)) "in use"
|
||||
@@ -274,10 +280,12 @@ object DeviceReport {
|
||||
EsyncPacks.status(LinuxRuntime.rootDir(context)).let { k("droiddeck-esync packs", "${it.installed} installed, ${it.wanted} wanted") }
|
||||
k("Linux x86 (FEX)", if (com.droiddeck.launcher.runtime.LinuxFex.ready(context)) "ready" else "not set up")
|
||||
k("gamescope realtime", SessionPrefs.gamescopeRealtime(context))
|
||||
k("pace cores", SessionPrefs.paceCores(context))
|
||||
k("zRAM: compress Steam during games", SessionPrefs.zramClient(context))
|
||||
k("RAM cap", SessionPrefs.ramCapMb(context).let { if (it > 0) "$it MB" else "off" })
|
||||
k("VRAM cap", SessionPrefs.vramCapMb(context).let { if (it > 0) "$it MB" else "driver default" })
|
||||
k("proot without seccomp", SessionPrefs.prootNoSeccomp(context))
|
||||
k("native userland (no proot)", SessionPrefs.nativeUserland(context))
|
||||
k("proot fast path", SessionPrefs.prootFastPath(context))
|
||||
k("proot binary", LinuxRuntime.prootSource(context) + " " + LinuxRuntime.prootBinary(context).path)
|
||||
k("proot fast path (eligible)", com.droiddeck.launcher.runtime.ProotFastPath.enabled(context))
|
||||
@@ -288,6 +296,8 @@ object DeviceReport {
|
||||
k("Microphone", SessionPrefs.micEnabled(context))
|
||||
k("On-screen controls", SessionPrefs.oscMode(context))
|
||||
k("Touch mode", SessionPrefs.touchMode(context))
|
||||
k("Pen mode", SessionPrefs.penMode(context))
|
||||
k("Pen side button", SessionPrefs.penButton(context))
|
||||
k("Performance HUD", SessionPrefs.hudEnabled(context))
|
||||
k("Game storage", when (val g = SessionPrefs.gameStorage(context)) {
|
||||
"" -> "automatic (" + (com.droiddeck.launcher.session.GameStorage.effective(context)?.path ?: "no card present") + ")"
|
||||
|
||||
@@ -31,8 +31,26 @@ public final class Downloader {
|
||||
return thread;
|
||||
});
|
||||
|
||||
private static final ThreadLocal<String> LAST_FAILURE = new ThreadLocal<>();
|
||||
|
||||
private Downloader() {}
|
||||
|
||||
public static String lastFailure() {
|
||||
return LAST_FAILURE.get();
|
||||
}
|
||||
|
||||
private static void failed(String url, String reason) {
|
||||
String host;
|
||||
try { host = new java.net.URI(url).getHost(); } catch (java.net.URISyntaxException e) { host = null; }
|
||||
String entry = (host == null ? url : host) + ": " + reason;
|
||||
String earlier = LAST_FAILURE.get();
|
||||
LAST_FAILURE.set(earlier == null ? entry : earlier + "; " + entry);
|
||||
}
|
||||
|
||||
private static String describe(Exception e) {
|
||||
return e.getMessage() == null ? e.getClass().getSimpleName() : e.getClass().getSimpleName() + ": " + e.getMessage();
|
||||
}
|
||||
|
||||
public static final class Cancellation implements java.util.function.BooleanSupplier {
|
||||
private final AtomicBoolean cancelled = new AtomicBoolean();
|
||||
private final AtomicReference<HttpURLConnection> connection = new AtomicReference<>();
|
||||
@@ -87,12 +105,14 @@ public final class Downloader {
|
||||
|
||||
public static String downloadString(String url, java.util.function.BooleanSupplier cancelled) {
|
||||
List<String> sources = DownloadSource.INSTANCE.candidates(url);
|
||||
LAST_FAILURE.remove();
|
||||
for (int i = 0; i < sources.size(); i++) {
|
||||
if (isCancelled(cancelled)) return null;
|
||||
if (i > 0) Log.i(TAG, "retrying " + url + " via " + sources.get(i));
|
||||
Fetch fetch = fetch(sources.get(i), cancelled);
|
||||
if (isCancelled(cancelled)) return null;
|
||||
if (fetch.body != null) {
|
||||
LAST_FAILURE.remove();
|
||||
DownloadSource.INSTANCE.succeeded(sources.get(i));
|
||||
return fetch.body;
|
||||
}
|
||||
@@ -103,6 +123,7 @@ public final class Downloader {
|
||||
}
|
||||
|
||||
public static String downloadDirect(String url) {
|
||||
LAST_FAILURE.remove();
|
||||
return fetch(url).body;
|
||||
}
|
||||
|
||||
@@ -138,6 +159,7 @@ public final class Downloader {
|
||||
String expectedSha256, java.util.function.BooleanSupplier cancelled,
|
||||
java.util.function.Consumer<Float> progress) {
|
||||
Identity identity = loadIdentity(destination, resume, expectedSha256);
|
||||
LAST_FAILURE.remove();
|
||||
for (int i = 0; i < sources.size(); i++) {
|
||||
String source = sources.get(i);
|
||||
if (isCancelled(cancelled)) return false;
|
||||
@@ -150,12 +172,14 @@ public final class Downloader {
|
||||
if (isCancelled(cancelled)) return false;
|
||||
if (!expectedSha256.equalsIgnoreCase(actualSha256)) {
|
||||
Log.w(TAG, "checksum mismatch from " + source + "; trying another source");
|
||||
failed(source, "checksum mismatch");
|
||||
if (!discardPartial(destination, identity)) return false;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (isCancelled(cancelled)) return false;
|
||||
resumeFile(destination).delete();
|
||||
LAST_FAILURE.remove();
|
||||
DownloadSource.INSTANCE.succeeded(source);
|
||||
if (progress != null) progress.accept(1f);
|
||||
return true;
|
||||
@@ -260,6 +284,7 @@ public final class Downloader {
|
||||
}
|
||||
if (code / 100 != 2) {
|
||||
Log.w(TAG, url + " -> HTTP " + code);
|
||||
failed(url, "HTTP " + code);
|
||||
return code == HttpURLConnection.HTTP_NOT_FOUND || code == HttpURLConnection.HTTP_GONE
|
||||
? Outcome.FATAL : Outcome.RETRY;
|
||||
}
|
||||
@@ -308,11 +333,15 @@ public final class Downloader {
|
||||
if (cancelled instanceof Cancellation) ((Cancellation) cancelled).detach(input);
|
||||
}
|
||||
if (isCancelled(cancelled)) return Outcome.CANCELLED;
|
||||
if (total > 0 && written < total) return Outcome.RETRY;
|
||||
if (total > 0 && written < total) {
|
||||
failed(url, "connection closed after " + written + " of " + total + " bytes");
|
||||
return Outcome.RETRY;
|
||||
}
|
||||
return Outcome.DONE;
|
||||
} catch (Exception e) {
|
||||
if (isCancelled(cancelled)) return Outcome.CANCELLED;
|
||||
Log.w(TAG, "download " + url, e);
|
||||
failed(url, describe(e));
|
||||
return Outcome.RETRY;
|
||||
} finally {
|
||||
if (connection != null) {
|
||||
@@ -357,6 +386,7 @@ public final class Downloader {
|
||||
int code = connection.getResponseCode();
|
||||
if (code / 100 != 2) {
|
||||
Log.w(TAG, url + " -> HTTP " + code);
|
||||
failed(url, "HTTP " + code);
|
||||
return new Fetch(null, code == HttpURLConnection.HTTP_NOT_FOUND || code == HttpURLConnection.HTTP_GONE);
|
||||
}
|
||||
try (InputStream in = connection.getInputStream();
|
||||
@@ -367,6 +397,7 @@ public final class Downloader {
|
||||
} catch (Exception e) {
|
||||
if (isCancelled(cancelled)) return new Fetch(null, false);
|
||||
Log.w(TAG, "GET " + url, e);
|
||||
failed(url, describe(e));
|
||||
return new Fetch(null, false);
|
||||
} finally {
|
||||
if (connection != null) {
|
||||
|
||||
@@ -49,6 +49,16 @@ object GameEnvironment {
|
||||
return withScopeValue(config, scope, NO_STEAM, if (on) "1" else null)
|
||||
}
|
||||
|
||||
const val GAME_RESOLUTION = "DROIDDECK_GAME_RESOLUTION"
|
||||
|
||||
fun gameResolution(config: Config, scope: String): GameResolution.Choice? =
|
||||
if (scope.isEmpty()) null else GameResolution.parse(config.games[scope]?.get(GAME_RESOLUTION))
|
||||
|
||||
fun withGameResolution(config: Config, scope: String, choice: GameResolution.Choice?): Config {
|
||||
require(scope.isNotEmpty() && validScope(scope))
|
||||
return withScopeValue(config, scope, GAME_RESOLUTION, choice?.let(GameResolution::format))
|
||||
}
|
||||
|
||||
fun effective(config: Config, preset: String, scope: String, forceSsbs: Boolean = false): Map<String, String?> =
|
||||
defaults(preset, forceSsbs) + config.shared + if (scope.isEmpty()) emptyMap() else config.games[scope].orEmpty()
|
||||
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
package com.droiddeck.launcher.core
|
||||
|
||||
object GameResolution {
|
||||
sealed interface Choice
|
||||
data class Fixed(val width: Int, val height: Int) : Choice
|
||||
data class Scaled(val scale: Float) : Choice
|
||||
|
||||
data class Aspect(val label: String, val sizes: List<Fixed>)
|
||||
|
||||
val aspects = listOf(
|
||||
Aspect("16:9", listOf(Fixed(960, 540), Fixed(1280, 720), Fixed(1600, 900), Fixed(1920, 1080), Fixed(2560, 1440))),
|
||||
Aspect("16:10", listOf(Fixed(1280, 800), Fixed(1440, 900), Fixed(1680, 1050), Fixed(1920, 1200), Fixed(2560, 1600))),
|
||||
Aspect("4:3", listOf(Fixed(640, 480), Fixed(800, 600), Fixed(1024, 768), Fixed(1280, 960), Fixed(1440, 1080))),
|
||||
)
|
||||
|
||||
val scales = listOf(1.5f, 2f, 3f)
|
||||
|
||||
const val MIN_WIDTH = 320
|
||||
const val MIN_HEIGHT = 240
|
||||
const val MAX_SIDE = 7680
|
||||
private const val SCALED_PREFIX = "/"
|
||||
|
||||
fun parse(value: String?): Choice? {
|
||||
val text = value?.trim().orEmpty()
|
||||
if (text.startsWith(SCALED_PREFIX)) {
|
||||
return text.removePrefix(SCALED_PREFIX).toFloatOrNull()?.takeIf { it > 1f && it <= 8f }?.let(::Scaled)
|
||||
}
|
||||
val parts = text.split('x', 'X', '×').map { it.trim().toIntOrNull() }
|
||||
if (parts.size != 2) return null
|
||||
val (w, h) = parts
|
||||
return if (w != null && h != null && valid(w, h)) Fixed(w and 1.inv(), h and 1.inv()) else null
|
||||
}
|
||||
|
||||
fun valid(width: Int, height: Int) = width in MIN_WIDTH..MAX_SIDE && height in MIN_HEIGHT..MAX_SIDE
|
||||
|
||||
fun format(choice: Choice): String = when (choice) {
|
||||
is Fixed -> "${choice.width}x${choice.height}"
|
||||
is Scaled -> SCALED_PREFIX + formatScale(choice.scale)
|
||||
}
|
||||
|
||||
fun formatScale(scale: Float): String =
|
||||
(Math.round(scale * 10) / 10f).let { if (it % 1f == 0f) it.toInt().toString() else it.toString() }
|
||||
|
||||
fun resolve(choice: Choice, output: Pair<Int, Int>): Pair<Int, Int> = when (choice) {
|
||||
is Fixed -> choice.width to choice.height
|
||||
is Scaled -> (Math.round(output.first / choice.scale).coerceAtLeast(MIN_WIDTH) and 1.inv()) to
|
||||
(Math.round(output.second / choice.scale).coerceAtLeast(MIN_HEIGHT) and 1.inv())
|
||||
}
|
||||
|
||||
fun aspectLabel(width: Int, height: Int): String {
|
||||
if (width <= 0 || height <= 0) return ""
|
||||
val ratio = width.toFloat() / height
|
||||
aspects.firstOrNull { a ->
|
||||
val (w, h) = a.label.split(':').map(String::toFloat)
|
||||
kotlin.math.abs(ratio - w / h) < 0.02f
|
||||
}?.let { return it.label }
|
||||
if (kotlin.math.abs(ratio - 64f / 27f) < 0.04f || kotlin.math.abs(ratio - 21f / 9f) < 0.04f) return "21:9"
|
||||
val g = gcd(width, height)
|
||||
return if (width / g <= 32) "${width / g}:${height / g}" else String.format(java.util.Locale.ROOT, "%.2f:1", ratio)
|
||||
}
|
||||
|
||||
fun sizesFor(aspect: Aspect, panel: Pair<Int, Int>): List<Fixed> {
|
||||
val long = maxOf(panel.first, panel.second)
|
||||
val short = minOf(panel.first, panel.second)
|
||||
val fit = aspect.sizes.filter { it.width <= long && it.height <= short }
|
||||
return fit.ifEmpty { aspect.sizes.take(1) }
|
||||
}
|
||||
|
||||
private tailrec fun gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
|
||||
}
|
||||
@@ -13,6 +13,11 @@ object HostProcess {
|
||||
|
||||
@JvmStatic
|
||||
fun start(command: String, env: Array<String>?, dir: File?, onExit: Consumer<Int>?, onLine: Consumer<String>?, outputFile: File?): Int {
|
||||
return start(command, env, dir, onExit, onLine, outputFile, null)
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
fun start(command: String, env: Array<String>?, dir: File?, onExit: Consumer<Int>?, onLine: Consumer<String>?, outputFile: File?, onOutputComplete: Runnable?): Int {
|
||||
val argv = split(command)
|
||||
if (argv.isEmpty()) return -1
|
||||
return try {
|
||||
@@ -35,6 +40,8 @@ object HostProcess {
|
||||
try {
|
||||
process.inputStream.bufferedReader().useLines { lines -> lines.forEach { onLine.accept(it) } }
|
||||
} catch (e: Exception) {
|
||||
} finally {
|
||||
onOutputComplete?.run()
|
||||
}
|
||||
}, "proc-out-$pid").apply { priority = Thread.NORM_PRIORITY - 1; isDaemon = true; start() }
|
||||
}
|
||||
|
||||
@@ -5,6 +5,9 @@ import android.util.Log
|
||||
import java.io.BufferedWriter
|
||||
import java.io.File
|
||||
import java.io.FileOutputStream
|
||||
import java.nio.file.Files
|
||||
import java.nio.file.StandardCopyOption
|
||||
import java.util.concurrent.atomic.AtomicInteger
|
||||
|
||||
object SessionLogCapture {
|
||||
private const val TAG = "SessionLogCapture"
|
||||
@@ -15,7 +18,7 @@ object SessionLogCapture {
|
||||
private var syncer: Thread? = null
|
||||
|
||||
@Synchronized
|
||||
fun start(target: File) {
|
||||
fun start(target: File, sinceMillis: Long) {
|
||||
stop()
|
||||
try {
|
||||
val out = target.bufferedWriter()
|
||||
@@ -25,7 +28,7 @@ object SessionLogCapture {
|
||||
writer = out
|
||||
this.target = target
|
||||
pid = HostProcess.start(
|
||||
"/system/bin/logcat -v threadtime -T 1 --pid=" + Process.myPid(),
|
||||
command(Process.myPid(), sinceMillis),
|
||||
null, target.parentFile, null,
|
||||
) { line ->
|
||||
synchronized(this) {
|
||||
@@ -46,6 +49,11 @@ object SessionLogCapture {
|
||||
}
|
||||
}
|
||||
|
||||
internal fun command(pid: Int, sinceMillis: Long): String {
|
||||
val since = if (sinceMillis > 0) "%d.%03d".format(java.util.Locale.US, sinceMillis / 1000, sinceMillis % 1000) else "1"
|
||||
return "/system/bin/logcat -v threadtime -T $since --pid=$pid"
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun stopFor(dir: File) {
|
||||
val t = target ?: return
|
||||
@@ -104,4 +112,53 @@ object SessionLogCapture {
|
||||
Log.w(TAG, "could not dump the crash buffer", e)
|
||||
}
|
||||
}
|
||||
|
||||
fun dumpMemoryPressure(target: File) {
|
||||
var temporary: File? = null
|
||||
try {
|
||||
val staged = File.createTempFile(target.name, ".part", target.parentFile).also { temporary = it }
|
||||
val lines = StringBuilder()
|
||||
val done = java.util.concurrent.CountDownLatch(1)
|
||||
val outputDone = java.util.concurrent.CountDownLatch(1)
|
||||
val exitStatus = AtomicInteger(Int.MIN_VALUE)
|
||||
val pid = HostProcess.start(
|
||||
"/system/bin/logcat -b events -d -v threadtime -t 800", null, target.parentFile,
|
||||
{ status -> exitStatus.set(status); done.countDown() },
|
||||
{ line -> synchronized(lines) { lines.append(line).append('\n') } },
|
||||
null,
|
||||
outputDone::countDown,
|
||||
)
|
||||
val deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(10)
|
||||
val finished = if (pid == -1) false else {
|
||||
val exitTime = deadline - System.nanoTime()
|
||||
exitTime > 0 && done.await(exitTime, java.util.concurrent.TimeUnit.NANOSECONDS) &&
|
||||
(deadline - System.nanoTime()).let { it > 0 && outputDone.await(it, java.util.concurrent.TimeUnit.NANOSECONDS) }
|
||||
}
|
||||
val body = synchronized(lines) { lines.toString() }
|
||||
val status = exitStatus.get()
|
||||
val pressure = runCatching { File("/proc/pressure/memory").readText() }.getOrDefault("unavailable\n")
|
||||
val meminfo = runCatching { File("/proc/meminfo").readText() }.getOrDefault("unavailable\n")
|
||||
val gpu = runCatching { File("/sys/class/kgsl/kgsl/page_alloc").readText() }.getOrDefault("unavailable\n")
|
||||
staged.writeText(
|
||||
"Android memory events:\n" +
|
||||
when {
|
||||
pid == -1 -> "(logcat could not be started at all)\n"
|
||||
status != Int.MIN_VALUE && status != 0 -> "(logcat failed with exit status $status; no Android memory events were captured)\n" +
|
||||
if (body.isEmpty()) "" else "\nlogcat command output:\n$body"
|
||||
!finished -> if (body.isEmpty()) "(logcat did not finish within 10 s; nothing captured)\n"
|
||||
else body + "(logcat did not finish within 10 s; later events may be missing)\n"
|
||||
body.isNotEmpty() -> body
|
||||
else -> "(no readable events were returned)\n"
|
||||
} +
|
||||
"\n/proc/pressure/memory:\n$pressure\n/proc/meminfo:\n$meminfo\n/sys/class/kgsl/kgsl/page_alloc:\n$gpu"
|
||||
)
|
||||
Files.move(
|
||||
staged.toPath(), target.toPath(),
|
||||
StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE,
|
||||
)
|
||||
} catch (e: Exception) {
|
||||
temporary?.delete()
|
||||
Log.w(TAG, "could not dump memory pressure diagnostics", e)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
package com.droiddeck.launcher.core
|
||||
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
|
||||
class ShortcutsListingReceiver : BroadcastReceiver() {
|
||||
override fun onReceive(context: Context, intent: Intent) {
|
||||
if (intent.action == Intent.ACTION_MY_PACKAGE_REPLACED) SteamIntegration.syncShortcutsListing(context)
|
||||
}
|
||||
}
|
||||
@@ -1,20 +1,21 @@
|
||||
package com.droiddeck.launcher.core
|
||||
|
||||
import android.accessibilityservice.AccessibilityServiceInfo
|
||||
import android.content.ComponentName
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.PackageManager
|
||||
import android.net.Uri
|
||||
import android.provider.Settings
|
||||
import android.view.accessibility.AccessibilityManager
|
||||
import com.droiddeck.launcher.HomeApp
|
||||
import com.droiddeck.launcher.input.HomeButtonService
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
import com.droiddeck.shortcuts.Relay
|
||||
import java.io.File
|
||||
|
||||
object SteamIntegration {
|
||||
const val ACTION_SETUP = "com.droiddeck.launcher.STEAM_INTEGRATION"
|
||||
const val EXTRA_FEATURE = "integration_feature"
|
||||
const val SHORTCUTS_STATUS = "com.droiddeck.launcher.SHORTCUTS_INSTALL_STATUS"
|
||||
private const val SHORTCUTS_ASSET = "shortcuts.apk"
|
||||
enum class Feature { WIFI, BRIGHTNESS, HOME, SHORTCUTS }
|
||||
|
||||
data class State(
|
||||
@@ -36,11 +37,7 @@ object SteamIntegration {
|
||||
locationOn = WifiDiscovery.locationEnabled(context),
|
||||
brightness = Settings.System.canWrite(context),
|
||||
home = HomeApp.isDefault(context),
|
||||
shortcuts = context.getSystemService(AccessibilityManager::class.java)
|
||||
.getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_ALL_MASK).any {
|
||||
val service = it.resolveInfo.serviceInfo
|
||||
ComponentName(service.packageName, service.name) == ComponentName(context, HomeButtonService::class.java)
|
||||
},
|
||||
shortcuts = shortcutsEnabled(context),
|
||||
shortcutsRestricted = restrictedSettings(context),
|
||||
suggested = !SessionPrefs.sessionPrefs(context).getBoolean("steam_integration_seen", false),
|
||||
)
|
||||
@@ -48,48 +45,53 @@ object SteamIntegration {
|
||||
private fun restrictedSettings(context: Context): Boolean {
|
||||
if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.TIRAMISU) return false
|
||||
val mode = runCatching {
|
||||
val uid = context.packageManager.getApplicationInfo(Relay.PACKAGE, 0).uid
|
||||
context.getSystemService(android.app.AppOpsManager::class.java)
|
||||
.unsafeCheckOpNoThrow("android:access_restricted_settings", android.os.Process.myUid(), context.packageName)
|
||||
.unsafeCheckOpNoThrow("android:access_restricted_settings", uid, Relay.PACKAGE)
|
||||
}.getOrDefault(android.app.AppOpsManager.MODE_ALLOWED)
|
||||
return mode == android.app.AppOpsManager.MODE_ERRORED || mode == android.app.AppOpsManager.MODE_IGNORED
|
||||
}
|
||||
|
||||
private fun shortcutsComponent(context: Context) = ComponentName(context, HomeButtonService::class.java)
|
||||
private val shortcutsComponent = ComponentName(Relay.PACKAGE, Relay.SERVICE)
|
||||
|
||||
fun shortcutsChosen(context: Context): Boolean = shortcutsSelection(context) == true
|
||||
|
||||
private fun shortcutsSelection(context: Context): Boolean? {
|
||||
val target = shortcutsComponent(context)
|
||||
fun shortcutsEnabled(context: Context): Boolean {
|
||||
val enabled = runCatching {
|
||||
Settings.Secure.getString(context.contentResolver, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES)
|
||||
}.getOrElse { return null }.orEmpty()
|
||||
return enabled.split(':').any { ComponentName.unflattenFromString(it.trim()) == target }
|
||||
}.getOrNull().orEmpty()
|
||||
return enabled.split(':').any { ComponentName.unflattenFromString(it.trim()) == shortcutsComponent }
|
||||
}
|
||||
|
||||
fun setShortcutsListed(context: Context, listed: Boolean) {
|
||||
fun shortcutsListed(context: Context): Boolean =
|
||||
context.getSystemService(android.view.accessibility.AccessibilityManager::class.java)
|
||||
?.installedAccessibilityServiceList.orEmpty()
|
||||
.any { ComponentName(it.resolveInfo.serviceInfo.packageName, it.resolveInfo.serviceInfo.name) == shortcutsComponent }
|
||||
|
||||
fun bundledShortcuts(context: Context): File {
|
||||
val target = File(context.cacheDir, SHORTCUTS_ASSET)
|
||||
context.assets.open(SHORTCUTS_ASSET).use { input -> target.outputStream().use { input.copyTo(it) } }
|
||||
return target
|
||||
}
|
||||
|
||||
fun shortcutsInstalled(context: Context, bundled: File): Boolean {
|
||||
val packages = context.packageManager
|
||||
val component = shortcutsComponent(context)
|
||||
val state = if (listed) PackageManager.COMPONENT_ENABLED_STATE_ENABLED else PackageManager.COMPONENT_ENABLED_STATE_DISABLED
|
||||
runCatching {
|
||||
if (packages.getComponentEnabledSetting(component) != state) {
|
||||
packages.setComponentEnabledSetting(component, state, PackageManager.DONT_KILL_APP)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun syncShortcutsListing(context: Context) {
|
||||
shortcutsSelection(context)?.let { setShortcutsListed(context, it) }
|
||||
@Suppress("DEPRECATION")
|
||||
val installed = runCatching { packages.getPackageInfo(Relay.PACKAGE, 0).versionCode }.getOrNull() ?: return false
|
||||
@Suppress("DEPRECATION")
|
||||
val shipped = packages.getPackageArchiveInfo(bundled.absolutePath, 0)?.versionCode ?: return true
|
||||
return installed >= shipped
|
||||
}
|
||||
|
||||
fun dismissSuggestion(context: Context) {
|
||||
SessionPrefs.sessionPrefs(context).edit().putBoolean("steam_integration_seen", true).apply()
|
||||
}
|
||||
|
||||
fun shortcutsAppInfo() = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:${Relay.PACKAGE}"))
|
||||
|
||||
fun brightnessSettings(context: Context) = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS,
|
||||
Uri.parse("package:${context.packageName}"))
|
||||
|
||||
fun shortcutSettings(context: Context): Intent {
|
||||
val service = ComponentName(context, HomeButtonService::class.java).flattenToString()
|
||||
val service = shortcutsComponent.flattenToString()
|
||||
return Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS)
|
||||
.putExtra(":settings:fragment_args_key", service)
|
||||
.putExtra(":settings:show_fragment_args", android.os.Bundle().apply { putString(":settings:fragment_args_key", service) })
|
||||
|
||||
@@ -41,6 +41,7 @@ object WirelessAdbFix {
|
||||
writeAtomically(context, key, identity.second)
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
private fun writeAtomically(context: Context, destination: File, contents: ByteArray) {
|
||||
val temporary = File(destination.parentFile, "${destination.name}.tmp")
|
||||
temporary.writeBytes(contents)
|
||||
@@ -70,6 +71,52 @@ object WirelessAdbFix {
|
||||
"$host:${saved.port ?: ""}"
|
||||
}
|
||||
|
||||
/**
|
||||
* The saved pairing's connect address, looked up again when it no longer answers: Wireless
|
||||
* debugging moves to another port whenever it restarts.
|
||||
*/
|
||||
fun liveConnectAddress(context: Context): String? {
|
||||
val app = context.applicationContext
|
||||
val saved = savedConnection(app) ?: return null
|
||||
val host = if (':' in saved.host) "[${saved.host}]" else saved.host
|
||||
saved.port?.takeIf { answers(saved.host, it) }?.let { return "$host:$it" }
|
||||
val loopback = runCatching { InetAddress.getByName(saved.host).isLoopbackAddress }.getOrDefault(false)
|
||||
val port = if (loopback) loopbackAdbPort(app) else findConnectPort(app, saved.host, accept = { answers(saved.host, it) })
|
||||
port ?: return null
|
||||
saveConnection(app, saved.host, port)
|
||||
return "$host:$port"
|
||||
}
|
||||
|
||||
/**
|
||||
* Wireless debugging's port on this device. Apps can read neither service.adb.tls.port nor the
|
||||
* socket table, and mDNS often advertises nothing, so the ephemeral range Linux gives adbd is
|
||||
* scanned on loopback (closed ports refuse at once) and the open ports are tried with our key.
|
||||
*/
|
||||
private fun loopbackAdbPort(app: Context): Int? {
|
||||
val open = java.util.concurrent.ConcurrentLinkedQueue<Int>()
|
||||
val workers = 32
|
||||
val range = EPHEMERAL_PORTS
|
||||
(0 until workers).map { worker ->
|
||||
Thread {
|
||||
var port = range.first + worker
|
||||
while (port <= range.last) {
|
||||
if (answers(LOOPBACK, port, 150)) open += port
|
||||
port += workers
|
||||
}
|
||||
}.apply { start() }
|
||||
}.forEach { it.join() }
|
||||
loadOrCreateIdentity(app)
|
||||
return open.sorted().firstOrNull { port ->
|
||||
runCatching { Kadb.create(LOOPBACK, port, 1_000, 3_000).use { it.shell("true").exitCode == 0 } }.getOrDefault(false)
|
||||
}
|
||||
}
|
||||
|
||||
private val EPHEMERAL_PORTS = 32768..60999
|
||||
|
||||
private fun answers(host: String, port: Int, timeoutMs: Int = 500) = runCatching {
|
||||
java.net.Socket().use { it.connect(java.net.InetSocketAddress(host, port), timeoutMs) }
|
||||
}.isSuccess
|
||||
|
||||
private fun saveConnection(context: Context, host: String, port: Int) {
|
||||
writeAtomically(
|
||||
context,
|
||||
@@ -94,7 +141,8 @@ object WirelessAdbFix {
|
||||
.invoke(null, "service.adb.tls.port") as? String
|
||||
}.getOrNull()?.trim()?.toIntOrNull()?.takeIf { it in 1..65535 }
|
||||
|
||||
fun findConnectPort(context: Context, pairedHost: String, timeoutSeconds: Long = 12): Int? {
|
||||
/** [accept] can pass over stale services that still advertise a port Wireless debugging left. */
|
||||
fun findConnectPort(context: Context, pairedHost: String, timeoutSeconds: Long = 12, accept: (Int) -> Boolean = { true }): Int? {
|
||||
val manager = context.applicationContext.getSystemService(Context.NSD_SERVICE) as NsdManager
|
||||
val paired = runCatching { InetAddress.getByName(pairedHost) }.getOrNull() ?: return null
|
||||
val matches: (InetAddress) -> Boolean =
|
||||
@@ -122,7 +170,7 @@ object WirelessAdbFix {
|
||||
|
||||
override fun onServiceResolved(serviceInfo: NsdServiceInfo) {
|
||||
val address = serviceInfo.host
|
||||
if (address != null && matches(address) && finished.compareAndSet(false, true)) {
|
||||
if (address != null && matches(address) && accept(serviceInfo.port) && finished.compareAndSet(false, true)) {
|
||||
resolvedPort.set(serviceInfo.port)
|
||||
latch.countDown()
|
||||
} else {
|
||||
|
||||
@@ -112,6 +112,10 @@ private const val HISTORY_LIMIT = 50
|
||||
internal fun canNavigateUp(currentDir: File, currentRoot: File): Boolean =
|
||||
currentDir != currentRoot && currentDir.parentFile?.exists() == true
|
||||
|
||||
// Back leaves after a drive hop instead of replaying a stack of hops one press at a time.
|
||||
internal fun backExitsAtRootHop(currentDir: File, currentRoot: File, previous: Pair<File, File>): Boolean =
|
||||
currentDir == currentRoot && previous.first == previous.second
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun FileManagerScreen(
|
||||
@@ -269,8 +273,10 @@ fun FileManagerScreen(
|
||||
if (showFavorites) showFavorites = false
|
||||
else {
|
||||
while (history.isNotEmpty() && !history.last().first.isDirectory) history.removeAt(history.lastIndex)
|
||||
val previous = history.removeLastOrNull()
|
||||
if (previous != null) {
|
||||
val previous = history.lastOrNull()
|
||||
if (previous != null && backExitsAtRootHop(currentDir, currentRoot, previous)) onExit?.invoke()
|
||||
else if (previous != null) {
|
||||
history.removeLastOrNull()
|
||||
currentRoot = previous.second
|
||||
loadDirectory(previous.first, record = false)
|
||||
} else if (canNavigateUp(currentDir, currentRoot)) currentDir.parentFile?.let { loadDirectory(it, record = false) }
|
||||
|
||||
@@ -97,15 +97,16 @@ object AddedGames {
|
||||
return File(LinuxRuntime.rootDir(context), guest.removePrefix("/"))
|
||||
}
|
||||
|
||||
fun candidates(folder: File): List<File> = rank(folder).exes
|
||||
fun candidates(folder: File, reuse: Boolean = false): List<File> = rank(folder, reuse).exes
|
||||
|
||||
fun rank(folder: File, reuse: Boolean = false): GameExePicker.Ranking {
|
||||
val key = "${folder.path}|${folder.lastModified()}"
|
||||
val declared = declaredExes(folder)
|
||||
val stamp = declared.fold(0L) { hash, exe -> hash * 31 + exe.path.hashCode() }
|
||||
val key = "${folder.path}|${folder.lastModified()}|$stamp"
|
||||
val now = System.currentTimeMillis()
|
||||
ranked[key]?.takeIf { now - it.first < RANK_FRESH_MS }?.let { return it.second }
|
||||
if (reuse) kept?.rank(folder)?.let { return it }
|
||||
if (reuse) kept?.rank(folder, stamp)?.let { return it }
|
||||
val guessed = GameExePicker.rank(folder) { !skipExe(it.name) }
|
||||
val declared = declaredExes(folder)
|
||||
val preferred = declared.map { it.path }.toSet()
|
||||
val result = if (declared.isEmpty()) guessed else GameExePicker.Ranking(
|
||||
declared + guessed.exes.filter { it.path !in preferred },
|
||||
@@ -115,7 +116,7 @@ object AddedGames {
|
||||
)
|
||||
if (ranked.size > 256) ranked.clear()
|
||||
ranked[key] = now to result
|
||||
kept?.keepRank(folder, result)
|
||||
kept?.keepRank(folder, result, stamp)
|
||||
return result
|
||||
}
|
||||
|
||||
@@ -200,8 +201,7 @@ object AddedGames {
|
||||
private val scanning = Any()
|
||||
|
||||
fun scan(context: Context): List<Game> = synchronized(scanning) {
|
||||
val file = File(context.filesDir, AddedGamesCache.FILE)
|
||||
val cache = kept?.takeIf { it.file == file } ?: AddedGamesCache(file).also { kept = it }
|
||||
val cache = cache(context)
|
||||
try {
|
||||
scanAll(context)
|
||||
} finally {
|
||||
@@ -209,6 +209,13 @@ object AddedGames {
|
||||
}
|
||||
}
|
||||
|
||||
private val keeping = Any()
|
||||
|
||||
private fun cache(context: Context): AddedGamesCache = synchronized(keeping) {
|
||||
val file = File(context.filesDir, AddedGamesCache.FILE)
|
||||
kept?.takeIf { it.file == file } ?: AddedGamesCache(file).also { kept = it }
|
||||
}
|
||||
|
||||
private fun scanAll(context: Context): List<Game> {
|
||||
val out = ArrayList<Game>()
|
||||
GamesFolderMigration.run(context)
|
||||
@@ -241,11 +248,17 @@ object AddedGames {
|
||||
return out.distinctBy { it.folder.canonicalPath }
|
||||
}
|
||||
|
||||
fun single(context: Context, folderPath: String): Game? {
|
||||
fun single(context: Context, folderPath: String, reuse: Boolean = false): Game? {
|
||||
val folder = File(folderPath)
|
||||
if (!folder.isDirectory || folderPath in SessionPrefs.removedAddedGames(context)) return null
|
||||
val out = ArrayList<Game>(1)
|
||||
scanGame(context, folder, out, single = AddedExes.list(context).firstOrNull { it.folder == folderPath })
|
||||
val entry = AddedExes.list(context).firstOrNull { it.folder == folderPath }
|
||||
val cache = if (reuse) cache(context) else null
|
||||
try {
|
||||
scanGame(context, folder, out, single = entry, reuse = reuse)
|
||||
} finally {
|
||||
cache?.save()
|
||||
}
|
||||
return out.firstOrNull()
|
||||
}
|
||||
|
||||
@@ -418,6 +431,7 @@ object AddedGames {
|
||||
private fun scanGame(context: Context, folder: File, out: MutableList<Game>, single: AddedExes.Entry? = null, reuse: Boolean = false) {
|
||||
run {
|
||||
val sidecar = StoreGameSidecar.read(folder)?.let { com.droiddeck.launcher.stores.StoreLaunch.adopt(folder, it) }
|
||||
if (sidecar?.store == Store.ROCKSTAR && sidecar.launcher != com.droiddeck.launcher.stores.StoreLaunch.LAUNCHER) return
|
||||
sidecar?.takeIf { it.id.isNotEmpty() }?.let { SessionPrefs.followStoreGame(context, "${it.store.id}:${it.id}", folder.path) { old -> !File(old).exists() } }
|
||||
val ranking = rank(folder, reuse)
|
||||
val candidates = ranking.exes
|
||||
@@ -433,6 +447,7 @@ object AddedGames {
|
||||
val autoName = sidecar?.title ?: identifiedName(folder, found) ?: folder.name
|
||||
val crc = CRC32().apply { update(("\"${foundGuest.replaceFirst(Regex("^$LIBRARY/"), "$LEGACY_LIBRARY/")}\"" + autoName).toByteArray()) }.value
|
||||
val appId = SessionPrefs.addedGameAppId(context, folder.path, crc or 0x80000000L)
|
||||
if (sidecar?.store == Store.ROCKSTAR) com.droiddeck.launcher.stores.rockstar.RockstarLaunch.applyDefaults(context, sidecar.id, appId)
|
||||
val config = accountConfig(SessionPrefs.activeSteamRoot(context))
|
||||
val record = config?.let { shortcutRecord(it, appId) }
|
||||
val rev = record?.optInt("rev", 0) ?: 0
|
||||
@@ -527,6 +542,17 @@ object AddedGames {
|
||||
}
|
||||
}
|
||||
|
||||
class Listed(val appId: Long, val name: String, val launchOptions: String)
|
||||
|
||||
fun listed(context: Context): List<Listed>? = runCatching {
|
||||
val file = File(context.filesDir, "session/added-games.json")
|
||||
if (!file.isFile) return null
|
||||
val entries = org.json.JSONArray(file.readText())
|
||||
(0 until entries.length()).mapNotNull { i ->
|
||||
entries.optJSONObject(i)?.takeIf { it.has("appid") }?.let { Listed(it.optLong("appid") and 0xFFFFFFFFL, it.optString("name"), it.optString("launch")) }
|
||||
}
|
||||
}.getOrNull()
|
||||
|
||||
fun writeListing(context: Context, games: List<Game>,
|
||||
extra: List<JSONObject> = listOfNotNull(com.droiddeck.launcher.stores.epic.EpicClient.steamListing(context))): File {
|
||||
val file = File(context.filesDir, "session/added-games.json").apply { parentFile?.mkdirs() }
|
||||
|
||||
@@ -7,7 +7,7 @@ import java.io.File
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
|
||||
internal class AddedGamesCache(val file: File) {
|
||||
private class Rank(val modified: Long, val at: Long, val ranking: GameExePicker.Ranking)
|
||||
private class Rank(val modified: Long, val declared: Long, val at: Long, val ranking: GameExePicker.Ranking)
|
||||
private class Name(val name: String, val at: Long)
|
||||
|
||||
private val ranks = ConcurrentHashMap<String, Rank>()
|
||||
@@ -22,7 +22,7 @@ internal class AddedGamesCache(val file: File) {
|
||||
val exes = o.getJSONArray("exes")
|
||||
val scores = o.getJSONArray("scores")
|
||||
require(exes.length() > 0 && exes.length() == scores.length())
|
||||
ranks[path] = Rank(o.getLong("modified"), o.getLong("at"), GameExePicker.Ranking(
|
||||
ranks[path] = Rank(o.getLong("modified"), o.optLong("declared"), o.getLong("at"), GameExePicker.Ranking(
|
||||
List(exes.length()) { File(exes.getString(it)) }, List(scores.length()) { scores.getInt(it) }, o.optBoolean("uncertain"),
|
||||
))
|
||||
}
|
||||
@@ -32,19 +32,19 @@ internal class AddedGamesCache(val file: File) {
|
||||
}
|
||||
}
|
||||
|
||||
fun rank(folder: File): GameExePicker.Ranking? {
|
||||
fun rank(folder: File, declared: Long = 0): GameExePicker.Ranking? {
|
||||
val kept = ranks[folder.path] ?: return null
|
||||
val age = System.currentTimeMillis() - kept.at
|
||||
val top = kept.ranking.exes.first()
|
||||
return kept.ranking.takeIf { kept.modified == folder.lastModified() && age in 0 until KEEP_MS && top.isFile }
|
||||
return kept.ranking.takeIf { kept.modified == folder.lastModified() && kept.declared == declared && age in 0 until KEEP_MS && top.isFile }
|
||||
}
|
||||
|
||||
fun keepRank(folder: File, ranking: GameExePicker.Ranking) {
|
||||
fun keepRank(folder: File, ranking: GameExePicker.Ranking, declared: Long = 0) {
|
||||
if (ranking.exes.isEmpty()) {
|
||||
if (ranks.remove(folder.path) != null) changed = true
|
||||
return
|
||||
}
|
||||
ranks[folder.path] = Rank(folder.lastModified(), System.currentTimeMillis(), ranking)
|
||||
ranks[folder.path] = Rank(folder.lastModified(), declared, System.currentTimeMillis(), ranking)
|
||||
changed = true
|
||||
}
|
||||
|
||||
@@ -62,7 +62,7 @@ internal class AddedGamesCache(val file: File) {
|
||||
val oldest = System.currentTimeMillis() - KEEP_MS
|
||||
val keptRanks = JSONObject()
|
||||
ranks.forEach { (path, r) ->
|
||||
if (r.at >= oldest) keptRanks.put(path, JSONObject().put("modified", r.modified).put("at", r.at)
|
||||
if (r.at >= oldest) keptRanks.put(path, JSONObject().put("modified", r.modified).put("declared", r.declared).put("at", r.at)
|
||||
.put("exes", JSONArray(r.ranking.exes.map { it.path })).put("scores", JSONArray(r.ranking.scores))
|
||||
.put("uncertain", r.ranking.uncertain))
|
||||
}
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.content.Context
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
|
||||
object AddedSoundtracks {
|
||||
private fun file(context: Context) = File(context.filesDir, "added-soundtracks.json")
|
||||
|
||||
class Entry(val path: String, val name: String, val id: Int = 0)
|
||||
|
||||
internal fun assignIds(list: List<Entry>): List<Entry> {
|
||||
val used = list.filter { it.id != 0 }.map { it.id }.toMutableSet()
|
||||
return list.map { e ->
|
||||
if (e.id != 0) e else {
|
||||
var id = idOf(e.path)
|
||||
while (id == 0 || !used.add(id)) id = (id + 1) or Int.MIN_VALUE
|
||||
Entry(e.path, e.name, id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun entries(context: Context): List<Entry> = runCatching {
|
||||
val f = file(context).takeIf { it.isFile } ?: return emptyList()
|
||||
val array = JSONArray(f.readText())
|
||||
val raw = List(array.length()) { i -> array.getJSONObject(i).let { Entry(it.getString("path"), it.getString("name"), it.optInt("id", 0)) } }
|
||||
val ready = assignIds(raw)
|
||||
if (raw.any { it.id == 0 }) save(context, ready)
|
||||
ready
|
||||
}.getOrDefault(emptyList())
|
||||
|
||||
@Synchronized
|
||||
private fun save(context: Context, list: List<Entry>): Boolean =
|
||||
runCatching {
|
||||
val array = JSONArray()
|
||||
list.forEach { array.put(JSONObject().put("path", it.path).put("name", it.name).put("id", it.id)) }
|
||||
val f = file(context)
|
||||
val tmp = File(f.path + ".tmp")
|
||||
tmp.writeText(array.toString())
|
||||
if (tmp.renameTo(f)) true else { tmp.delete(); false }
|
||||
}.getOrDefault(false)
|
||||
|
||||
fun add(context: Context, folder: File): Boolean {
|
||||
if (!folder.isDirectory || Soundtrack.audioFiles(folder).isEmpty()) return false
|
||||
return synchronized(this) {
|
||||
val list = entries(context)
|
||||
list.any { it.path == folder.path } || save(context, assignIds(list + Entry(folder.path, folder.name)))
|
||||
}
|
||||
}
|
||||
|
||||
fun remove(context: Context, path: String): Boolean =
|
||||
synchronized(this) { save(context, entries(context).filterNot { it.path == path }) }
|
||||
|
||||
internal fun idOf(path: String): Int = path.hashCode() or Int.MIN_VALUE
|
||||
|
||||
fun games(context: Context): List<Library.SteamGame> = entries(context).mapNotNull { e ->
|
||||
val dir = File(e.path).takeIf { it.isDirectory } ?: return@mapNotNull null
|
||||
game(context, e, dir, e.id)
|
||||
}
|
||||
|
||||
private fun game(context: Context, e: Entry, dir: File, id: Int): Library.SteamGame {
|
||||
return Library.SteamGame(
|
||||
appId = id, name = e.name, art = SoundtrackCollectionArt.chosen(context, id) ?: Soundtrack.firstCover(context, dir), library = Library.ADDED, gameId = id.toLong() and 0xFFFFFFFFL,
|
||||
gameFiles = dir, source = Library.ADDED, soundtrack = true,
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -43,11 +43,14 @@ object GameFileSync {
|
||||
val storageSetting = SessionPrefs.gameStorage(context)
|
||||
val previousStorage = prefs(context).getString("storagePath", null)
|
||||
if (storageSetting.isEmpty() && prefs(context).getString("storageSetting", null) == storageSetting && previousStorage != null) {
|
||||
check(File(previousStorage).isDirectory) { context.getString(R.string.game_sync_err_previous_sd) }
|
||||
check(libraryReadable(File(previousStorage))) { context.getString(R.string.game_sync_err_previous_sd) }
|
||||
}
|
||||
storage?.let { check(File(it.path).listFiles() != null) { context.getString(R.string.game_sync_err_game_storage) } }
|
||||
storage?.let { check(libraryReadable(File(it.path))) { context.getString(R.string.game_sync_err_game_storage) } }
|
||||
AddedGames.roots(context).forEach { check(it.host.listFiles() != null) { context.getString(R.string.game_sync_err_added_games) } }
|
||||
GameFiles.sync(context, folder, Library.launchableGames(context, strictRead = true))
|
||||
prefs(context).edit().putString("storageSetting", storageSetting).putString("storagePath", storage?.path).apply()
|
||||
}
|
||||
|
||||
internal fun libraryReadable(dir: File): Boolean =
|
||||
dir.listFiles() != null || (!dir.exists() && dir.parentFile?.isDirectory == true)
|
||||
}
|
||||
@@ -21,7 +21,7 @@ object GameRemoval {
|
||||
fun steamFiles(game: Library.SteamGame): SteamFiles? {
|
||||
val dir = game.gameFiles ?: return null
|
||||
val common = dir.parentFile ?: return null
|
||||
if (common.name != "common") return null
|
||||
if (common.name != (if (game.soundtrack) "music" else "common")) return null
|
||||
val steamapps = common.parentFile ?: return null
|
||||
if (steamapps.name != "steamapps") return null
|
||||
val manifest = File(steamapps, "appmanifest_${game.appId}.acf")
|
||||
|
||||
@@ -19,9 +19,10 @@ object Library {
|
||||
val storeId: String? = null,
|
||||
val logo: File? = null,
|
||||
val installedAt: Long = 0L,
|
||||
val soundtrack: Boolean = false,
|
||||
) {
|
||||
fun withArt(art: File?, hero: File?, icon: File?, logo: File? = this.logo) =
|
||||
SteamGame(appId, name, art, library, gameId, hero, lastPlayed, gameFiles, protonPrefix, icon, source, storeId, logo, installedAt)
|
||||
SteamGame(appId, name, art, library, gameId, hero, lastPlayed, gameFiles, protonPrefix, icon, source, storeId, logo, installedAt, soundtrack)
|
||||
|
||||
val gameIdString: String get() = java.lang.Long.toUnsignedString(gameId)
|
||||
val launchKey: String get() = if (storeId != null) "$source:$storeId" else gameIdString
|
||||
@@ -38,6 +39,7 @@ object Library {
|
||||
const val BATTLENET_LAUNCHER = "battlenet-launcher"
|
||||
const val XBOX_CLOUD = "xbox-cloud"
|
||||
const val SOURCE_STEAM = "steam"
|
||||
const val SOURCE_COLLECTION = "collection"
|
||||
|
||||
class Rom(val name: String, val hostPath: File, val guestPath: String, val emulatorId: String, val art: File? = null)
|
||||
class Emulator(val id: String, val name: String, val system: String, val program: String, val installed: Boolean, val games: List<Rom>) {
|
||||
@@ -123,9 +125,13 @@ object Library {
|
||||
.distinctBy { runCatching { it.canonicalPath }.getOrDefault(it.absolutePath) }
|
||||
}
|
||||
|
||||
fun soundtracks(context: Context, arch: String = SessionPrefs.activeSteamClientArch(context)): List<SteamGame> =
|
||||
steamGames(context, arch = arch, withShared = false, soundtracks = true, soundtracksOnly = true)
|
||||
|
||||
fun steamGames(
|
||||
context: Context, strictRead: Boolean = false, arch: String = SessionPrefs.activeSteamClientArch(context),
|
||||
withShared: Boolean = true,
|
||||
withShared: Boolean = true, soundtracks: Boolean = false, soundtracksOnly: Boolean = false,
|
||||
onlyAppIds: Set<Int>? = null,
|
||||
): List<SteamGame> {
|
||||
val root = SessionPrefs.steamRoot(context, arch)
|
||||
val cache = File(root, "appcache/librarycache")
|
||||
@@ -138,21 +144,26 @@ object Library {
|
||||
if (strictRead && steamapps.isDirectory) check(manifests != null) { context.getString(R.string.game_sync_err_manifests) }
|
||||
manifests?.sortedBy { it.name }?.forEach { manifest ->
|
||||
val appId = manifest.name.removePrefix("appmanifest_").removeSuffix(".acf").toIntOrNull() ?: return@forEach
|
||||
if (appId in NOT_GAMES || out.containsKey(appId)) return@forEach
|
||||
if (appId in NOT_GAMES || out.containsKey(appId) ||
|
||||
(onlyAppIds != null && appId !in onlyAppIds)
|
||||
) return@forEach
|
||||
val text = try { manifest.readText() } catch (e: Exception) { if (strictRead) throw e; return@forEach }
|
||||
val name = NAME.find(text)?.groupValues?.get(1)?.trim().orEmpty()
|
||||
val flags = STATE.find(text)?.groupValues?.get(1)?.toIntOrNull() ?: 0
|
||||
if (name.isEmpty() || flags and 4 == 0) return@forEach
|
||||
val installDir = INSTALL_DIR.find(text)?.groupValues?.get(1)?.trim()
|
||||
?.takeIf { it.isNotEmpty() && it != "." && it != ".." && '/' !in it && '\\' !in it }
|
||||
val gameFiles = installDir?.let { File(steamapps, "common/$it").takeIf(File::isDirectory) }
|
||||
val musicFiles = if (gameFiles == null) installDir?.let { File(steamapps, "music/$it").takeIf(File::isDirectory) } else null
|
||||
if (musicFiles != null && !soundtracks) return@forEach
|
||||
if (soundtracksOnly && musicFiles == null) return@forEach
|
||||
val images = SteamCacheImages(File(cache, appId.toString()))
|
||||
val art = images.find(STEAM_CAPSULES)
|
||||
val hero = images.find(STEAM_HEROES)
|
||||
val lastPlayed = LAST_PLAYED.find(text)?.groupValues?.get(1)?.toLongOrNull() ?: 0L
|
||||
val installDir = INSTALL_DIR.find(text)?.groupValues?.get(1)?.trim()
|
||||
?.takeIf { it.isNotEmpty() && it != "." && it != ".." && '/' !in it && '\\' !in it }
|
||||
val gameFiles = installDir?.let { File(steamapps, "common/$it").takeIf(File::isDirectory) }
|
||||
out[appId] = SteamGameArt.withOverrides(context, SteamGame(
|
||||
appId, name, art, label, hero = hero, lastPlayed = lastPlayed,
|
||||
gameFiles = gameFiles,
|
||||
appId, name, art ?: musicFiles?.let { Soundtrack.firstCover(context, it) }, label, hero = hero, lastPlayed = lastPlayed,
|
||||
gameFiles = gameFiles ?: musicFiles, soundtrack = musicFiles != null,
|
||||
protonPrefix = protonPrefix(context, appId.toLong(), library, roots),
|
||||
icon = images.icon(),
|
||||
logo = images.find(STEAM_LOGOS),
|
||||
@@ -161,16 +172,42 @@ object Library {
|
||||
}
|
||||
if (withShared) {
|
||||
val other = if (arch == "x86_64") "arm64" else "x86_64"
|
||||
val shared = sharedApps(context, arch) - out.keys
|
||||
if (shared.isNotEmpty()) runCatching { steamGames(context, arch = other, withShared = false) }.getOrDefault(emptyList())
|
||||
.filter { it.appId in shared }.forEach { out[it.appId] = it }
|
||||
val shared = try {
|
||||
sharedApps(context, arch) - out.keys
|
||||
} catch (e: IllegalStateException) {
|
||||
if (strictRead) throw e
|
||||
emptySet()
|
||||
}
|
||||
if (shared.isNotEmpty()) {
|
||||
val otherGames = try {
|
||||
steamGames(
|
||||
context,
|
||||
strictRead = strictRead,
|
||||
arch = other,
|
||||
withShared = false,
|
||||
soundtracks = soundtracks,
|
||||
onlyAppIds = shared,
|
||||
)
|
||||
} catch (e: Exception) {
|
||||
if (strictRead) throw e
|
||||
emptyList()
|
||||
}
|
||||
otherGames.forEach { out[it.appId] = it }
|
||||
}
|
||||
}
|
||||
return out.values.toList()
|
||||
}
|
||||
|
||||
internal fun sharedApps(context: Context, arch: String): Set<Int> {
|
||||
val view = File(LinuxRuntime.rootDir(context), "root/.droiddeck-x64/shared/${if (arch == "x86_64") "arm64" else "x86-64"}/steamapps")
|
||||
return view.list().orEmpty().mapNotNull { Regex("appmanifest_(\\d+)\\.acf").matchEntire(it)?.groupValues?.get(1)?.toIntOrNull() }.toSet()
|
||||
val entries = view.list()
|
||||
if (entries == null) {
|
||||
if (!view.exists()) return emptySet()
|
||||
throw IllegalStateException("Unable to read the shared Steam library.")
|
||||
}
|
||||
return entries.mapNotNull {
|
||||
Regex("appmanifest_(\\d+)\\.acf").matchEntire(it)?.groupValues?.get(1)?.toIntOrNull()
|
||||
}.toSet()
|
||||
}
|
||||
|
||||
fun steamLibraryArt(context: Context): List<Pair<Int, File>> {
|
||||
|
||||
@@ -0,0 +1,308 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.content.Context
|
||||
import android.media.MediaMetadataRetriever
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
|
||||
object Soundtrack {
|
||||
class Track(
|
||||
val file: File, val title: String, val disc: Int, val number: Int, val durationMs: Long, val artist: String = "",
|
||||
val discLabel: String = disc.toString(),
|
||||
) {
|
||||
val id: String get() = file.path
|
||||
}
|
||||
|
||||
class Album(val disc: Map<Int, List<Track>>, val artist: String, val cover: File?) {
|
||||
val tracks: List<Track> get() = disc.values.flatten()
|
||||
val discs: List<Int> get() = disc.keys.toList()
|
||||
val multiDisc: Boolean get() = disc.size > 1
|
||||
val totalMs: Long get() = tracks.sumOf { it.durationMs }
|
||||
}
|
||||
|
||||
class Raw(
|
||||
val file: File, val folder: String, val tagDisc: Int?, val tagTrack: Int?, val tagTitle: String?, val tagArtist: String?,
|
||||
val durationMs: Long, val size: Long = file.length(),
|
||||
)
|
||||
|
||||
val EXTENSIONS = setOf("mp3", "flac", "ogg", "oga", "opus", "wav", "m4a", "aac")
|
||||
private val LOSSLESS = setOf("flac", "wav")
|
||||
private val COVERS = listOf("AlbumArtwork", "albumartwork", "cover", "Cover", "folder", "Folder", "front", "Front", "artwork", "Artwork")
|
||||
internal val COVER_EXT = listOf("png", "jpg", "jpeg", "webp")
|
||||
private val LEADING = Regex("^\\s*\\d+\\s*[.\\-_)]*\\s+")
|
||||
private val DIGITS = Regex("^\\s*(\\d+)")
|
||||
|
||||
fun isAudio(file: File): Boolean = file.isFile && file.extension.lowercase() in EXTENSIONS
|
||||
|
||||
fun cleanTitle(fileName: String): String {
|
||||
val base = fileName.substringBeforeLast('.', fileName).trim()
|
||||
val tail = if (" - " in base) base.substringAfterLast(" - ") else base
|
||||
val stripped = tail.replace(LEADING, "").trim()
|
||||
return stripped.ifEmpty { tail.ifEmpty { base } }
|
||||
}
|
||||
|
||||
internal fun leadingNumber(fileName: String): Int? = DIGITS.find(fileName.substringAfterLast(" - "))?.groupValues?.get(1)?.toIntOrNull()
|
||||
|
||||
private fun identity(r: Raw): String {
|
||||
val d = r.tagDisc
|
||||
val t = r.tagTrack
|
||||
if (d != null && t != null) return "n:$d:$t"
|
||||
val title = (r.tagTitle?.takeIf { it.isNotBlank() } ?: cleanTitle(r.file.name)).lowercase().filter { it.isLetterOrDigit() }
|
||||
return "t:$title:${leadingNumber(r.file.name)}"
|
||||
}
|
||||
|
||||
private fun better(a: Raw, b: Raw): Raw {
|
||||
val la = a.file.extension.lowercase() in LOSSLESS
|
||||
val lb = b.file.extension.lowercase() in LOSSLESS
|
||||
return when {
|
||||
la != lb -> if (la) a else b
|
||||
a.size != b.size -> if (a.size > b.size) a else b
|
||||
else -> if (a.file.path <= b.file.path) a else b
|
||||
}
|
||||
}
|
||||
|
||||
fun group(raws: List<Raw>): Map<Int, List<Track>> {
|
||||
if (raws.isEmpty()) return emptyMap()
|
||||
val unique = LinkedHashMap<String, Raw>()
|
||||
val home = HashMap<String, String>()
|
||||
val disc = HashMap<String, Int>()
|
||||
val track = HashMap<String, Int>()
|
||||
val title = HashMap<String, String>()
|
||||
for (r in raws) {
|
||||
val id = identity(r)
|
||||
unique[id] = unique[id]?.let { better(it, r) } ?: r
|
||||
if (r.folder.isNotEmpty() && home[id].isNullOrEmpty()) home[id] = r.folder
|
||||
r.tagDisc?.let { disc.putIfAbsent(id, it) }
|
||||
r.tagTrack?.let { track.putIfAbsent(id, it) }
|
||||
r.tagTitle?.takeIf { it.isNotBlank() }?.let { title.putIfAbsent(id, it) }
|
||||
}
|
||||
val kept = unique.map { (id, r) ->
|
||||
Raw(
|
||||
r.file, home[id] ?: r.folder, disc[id] ?: r.tagDisc, track[id] ?: r.tagTrack, title[id] ?: r.tagTitle, r.tagArtist,
|
||||
r.durationMs, r.size,
|
||||
)
|
||||
}
|
||||
val folders = kept.filter { it.tagDisc == null }.map { it.folder }.distinct().sortedWith(naturalOrder)
|
||||
val discs = kept.groupBy { r ->
|
||||
r.tagDisc ?: if (folders.size <= 1 && kept.none { it.tagDisc != null }) 0 else folders.indexOf(r.folder) + 1
|
||||
}
|
||||
return discs.toSortedMap().mapValues { (disc, list) ->
|
||||
list.sortedWith(
|
||||
compareBy<Raw>({ leadingNumber(it.file.name) ?: it.tagTrack ?: Int.MAX_VALUE }, { it.tagTrack ?: Int.MAX_VALUE }, { it.file.name.lowercase() }),
|
||||
).mapIndexed { i, r ->
|
||||
Track(
|
||||
r.file, r.tagTitle?.takeIf { it.isNotBlank() } ?: cleanTitle(r.file.name), disc, i + 1,
|
||||
r.durationMs, r.tagArtist.orEmpty(), labelOf(r, disc),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private val FOLDER_LABEL = Regex("[0-9][0-9 +&,.\\-]*")
|
||||
|
||||
private fun labelOf(r: Raw, disc: Int): String {
|
||||
if (r.tagDisc != null) return disc.toString()
|
||||
val name = r.folder.substringAfterLast('/')
|
||||
return if (FOLDER_LABEL.matches(name)) name else disc.toString()
|
||||
}
|
||||
|
||||
private val naturalOrder = Comparator<String> { a, b ->
|
||||
val x = Regex("\\d+|\\D+").findAll(a.lowercase()).map { it.value }.toList()
|
||||
val y = Regex("\\d+|\\D+").findAll(b.lowercase()).map { it.value }.toList()
|
||||
var i = 0
|
||||
var out = 0
|
||||
while (out == 0 && i < minOf(x.size, y.size)) {
|
||||
val nx = x[i].toBigIntegerOrNull()
|
||||
val ny = y[i].toBigIntegerOrNull()
|
||||
out = if (nx != null && ny != null) nx.compareTo(ny) else x[i].compareTo(y[i])
|
||||
i++
|
||||
}
|
||||
if (out != 0) out else x.size.compareTo(y.size)
|
||||
}
|
||||
|
||||
fun cover(dir: File): File? {
|
||||
for (name in COVERS) for (ext in COVER_EXT) File(dir, "$name.$ext").takeIf { it.isFile }?.let { return it }
|
||||
return dir.listFiles()?.filter { it.isFile && it.extension.lowercase() in COVER_EXT }?.minByOrNull { it.name.lowercase() }
|
||||
}
|
||||
|
||||
private fun parseNumber(value: String?): Int? = value?.substringBefore('/')?.trim()?.toIntOrNull()
|
||||
|
||||
private fun read(file: File, root: File): Raw {
|
||||
val folder = file.parentFile?.let { parent ->
|
||||
if (parent.path == root.path) "" else parent.path.removePrefix(root.path).trimStart('/')
|
||||
}.orEmpty()
|
||||
val retriever = MediaMetadataRetriever()
|
||||
return try {
|
||||
retriever.setDataSource(file.path)
|
||||
Raw(
|
||||
file, folder,
|
||||
parseNumber(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DISC_NUMBER)),
|
||||
parseNumber(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CD_TRACK_NUMBER)),
|
||||
retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE),
|
||||
retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST)
|
||||
?: retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUMARTIST),
|
||||
retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull() ?: 0L,
|
||||
)
|
||||
} catch (e: Exception) {
|
||||
Raw(file, folder, null, null, null, null, 0L)
|
||||
} finally {
|
||||
runCatching { retriever.release() }
|
||||
}
|
||||
}
|
||||
|
||||
private fun cacheFile(context: Context, root: File) = File(context.filesDir, "soundtrack-index/${root.path.hashCode().toUInt()}.json")
|
||||
|
||||
private fun fromCache(context: Context, root: File, files: List<File>): List<Raw>? = runCatching {
|
||||
val f = cacheFile(context, root).takeIf { it.isFile } ?: return null
|
||||
val json = JSONObject(f.readText())
|
||||
if (json.optString("root") != root.path) return null
|
||||
val rows = json.getJSONArray("rows")
|
||||
val byPath = HashMap<String, JSONObject>()
|
||||
for (i in 0 until rows.length()) rows.getJSONObject(i).let { byPath[it.getString("p")] = it }
|
||||
if (byPath.size != files.size) return null
|
||||
files.map { file ->
|
||||
val row = byPath[file.path] ?: return null
|
||||
if (row.getLong("s") != file.length() || row.getLong("m") != file.lastModified()) return null
|
||||
Raw(
|
||||
file, row.getString("f"), row.optInt("d", -1).takeIf { it >= 0 }, row.optInt("n", -1).takeIf { it >= 0 },
|
||||
row.optString("t").takeIf { it.isNotEmpty() }, row.optString("a").takeIf { it.isNotEmpty() }, row.optLong("l"),
|
||||
)
|
||||
}
|
||||
}.getOrNull()
|
||||
|
||||
private fun toCache(context: Context, root: File, raws: List<Raw>) {
|
||||
runCatching {
|
||||
val rows = JSONArray()
|
||||
for (r in raws) rows.put(
|
||||
JSONObject().put("p", r.file.path).put("s", r.file.length()).put("m", r.file.lastModified()).put("f", r.folder)
|
||||
.put("d", r.tagDisc ?: -1).put("n", r.tagTrack ?: -1).put("t", r.tagTitle.orEmpty()).put("a", r.tagArtist.orEmpty())
|
||||
.put("l", r.durationMs),
|
||||
)
|
||||
val f = cacheFile(context, root)
|
||||
f.parentFile?.mkdirs()
|
||||
val tmp = File(f.path + ".tmp")
|
||||
tmp.writeText(JSONObject().put("root", root.path).put("rows", rows).toString())
|
||||
if (!tmp.renameTo(f)) tmp.delete()
|
||||
}
|
||||
}
|
||||
|
||||
fun audioFiles(root: File): List<File> {
|
||||
val out = ArrayList<File>()
|
||||
fun walk(dir: File, depth: Int) {
|
||||
val children = dir.listFiles() ?: return
|
||||
for (c in children.sortedBy { it.name.lowercase() }) {
|
||||
if (c.isDirectory) { if (depth < 4) walk(c, depth + 1) } else if (isAudio(c)) out += c
|
||||
}
|
||||
}
|
||||
walk(root, 0)
|
||||
return out
|
||||
}
|
||||
|
||||
private fun coverCache(context: Context, root: File): File {
|
||||
val digest = java.security.MessageDigest.getInstance("SHA-256").digest(root.path.toByteArray(Charsets.UTF_8))
|
||||
val key = digest.take(16).joinToString("") { "%02x".format(it) }
|
||||
return File(context.filesDir, "soundtrack-index/cover-$key.jpg")
|
||||
}
|
||||
|
||||
fun cachedCover(context: Context, root: File): File? = coverCache(context, root).takeIf { it.isFile && it.length() > 0L }
|
||||
|
||||
private fun embeddedBytes(file: File): ByteArray? = runCatching {
|
||||
val retriever = MediaMetadataRetriever()
|
||||
try {
|
||||
retriever.setDataSource(file.path)
|
||||
retriever.embeddedPicture
|
||||
} finally {
|
||||
runCatching { retriever.release() }
|
||||
}
|
||||
}.getOrNull()?.takeIf { it.isNotEmpty() }
|
||||
|
||||
private fun hashOf(bytes: ByteArray): String =
|
||||
java.security.MessageDigest.getInstance("SHA-256").digest(bytes).take(16).joinToString("") { "%02x".format(it) }
|
||||
|
||||
private fun embeddedCover(context: Context, root: File, files: List<File>): File? {
|
||||
cachedCover(context, root)?.let { return it }
|
||||
val miss = File(coverCache(context, root).path + ".none")
|
||||
val probed = files.take(8)
|
||||
val signature = hashOf(probed.joinToString("\n") { "${it.path}|${it.length()}|${it.lastModified()}" }.toByteArray(Charsets.UTF_8))
|
||||
if (runCatching { miss.isFile && miss.readText().trim() == signature }.getOrDefault(false)) return null
|
||||
for (file in probed) {
|
||||
val bytes = embeddedBytes(file) ?: continue
|
||||
val out = coverCache(context, root)
|
||||
runCatching {
|
||||
out.parentFile?.mkdirs()
|
||||
out.writeBytes(bytes)
|
||||
}.onSuccess { return out }
|
||||
}
|
||||
runCatching {
|
||||
miss.parentFile?.mkdirs()
|
||||
miss.writeText(signature)
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
fun firstCover(context: Context, root: File): File? = cover(root) ?: embeddedCover(context, root, audioFiles(root))
|
||||
|
||||
@Synchronized
|
||||
fun trackCover(context: Context, file: File): File? {
|
||||
val dir = File(context.filesDir, "soundtrack-index/track-covers")
|
||||
val marker = File(dir, "t-" + hashOf("${file.path}|${file.length()}|${file.lastModified()}".toByteArray(Charsets.UTF_8)))
|
||||
if (marker.isFile) {
|
||||
val name = runCatching { marker.readText().trim() }.getOrDefault("")
|
||||
if (name.isEmpty()) return null
|
||||
File(dir, name).takeIf { it.isFile && it.length() > 0L }?.let {
|
||||
val now = System.currentTimeMillis()
|
||||
marker.setLastModified(now)
|
||||
it.setLastModified(now)
|
||||
return it
|
||||
}
|
||||
}
|
||||
val bytes = embeddedBytes(file)
|
||||
return runCatching {
|
||||
dir.mkdirs()
|
||||
if (bytes == null) {
|
||||
marker.writeText("")
|
||||
prune(dir, setOf(marker.name))
|
||||
null
|
||||
} else {
|
||||
val out = File(dir, "c-" + hashOf(bytes) + ".jpg")
|
||||
if (!out.isFile || out.length() == 0L) out.writeBytes(bytes)
|
||||
marker.writeText(out.name)
|
||||
prune(dir, setOf(marker.name, out.name))
|
||||
out
|
||||
}
|
||||
}.getOrNull()
|
||||
}
|
||||
|
||||
private const val TRACK_COVER_BYTES = 64L * 1024 * 1024
|
||||
private const val TRACK_COVER_FILES = 2000
|
||||
|
||||
private fun prune(dir: File, keep: Set<String>) {
|
||||
val all = dir.listFiles()?.filter { it.isFile } ?: return
|
||||
var bytes = all.sumOf { it.length() }
|
||||
var count = all.size
|
||||
for (f in all.sortedBy { it.lastModified() }) {
|
||||
if (bytes <= TRACK_COVER_BYTES && count <= TRACK_COVER_FILES) break
|
||||
if (f.name in keep) continue
|
||||
bytes -= f.length()
|
||||
count--
|
||||
f.delete()
|
||||
}
|
||||
}
|
||||
|
||||
fun load(context: Context, root: File, coverHint: File? = null): Album {
|
||||
val files = audioFiles(root)
|
||||
val raws = fromCache(context, root, files) ?: files.map { read(it, root) }.also { toCache(context, root, it) }
|
||||
val disc = SoundtrackOrder.apply(context, root, group(raws))
|
||||
val artist = disc.values.flatten().map { it.artist }.filter { it.isNotBlank() }.groupingBy { it }.eachCount().maxByOrNull { it.value }?.key.orEmpty()
|
||||
return Album(disc, artist, coverHint ?: cover(root) ?: embeddedCover(context, root, files))
|
||||
}
|
||||
|
||||
fun formatLength(ms: Long): String {
|
||||
val total = ms / 1000
|
||||
val h = total / 3600
|
||||
val m = (total % 3600) / 60
|
||||
val s = total % 60
|
||||
return if (h > 0) "%d:%02d:%02d".format(h, m, s) else "%d:%02d".format(m, s)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.content.Context
|
||||
import java.io.File
|
||||
|
||||
object SoundtrackCollectionArt {
|
||||
internal fun dir(context: Context, id: Int) = File(context.filesDir, "soundtrack-art/$id")
|
||||
|
||||
private fun sourceFile(context: Context, id: Int) = File(dir(context, id), "source")
|
||||
|
||||
fun chosen(context: Context, id: Int): File? = dir(context, id).takeIf { it.isDirectory }?.let { AddedGameArt.chosen(it, AddedGameArt.Slot.COVER) }
|
||||
|
||||
fun source(context: Context, id: Int): String =
|
||||
sourceFile(context, id).takeIf { it.isFile }?.readText()?.trim().orEmpty().substringAfter('|', "")
|
||||
|
||||
fun options(context: Context, id: Int, root: File?): List<AddedGameArt.Option> {
|
||||
val paths = if (root != null) {
|
||||
val images = root.listFiles()?.filter { it.isFile && it.extension.lowercase() in Soundtrack.COVER_EXT }?.sortedBy { it.name.lowercase() }.orEmpty()
|
||||
(images + listOfNotNull(Soundtrack.firstCover(context, root))).map { it.path }
|
||||
} else SoundtrackCollections.tracksOf(id).map { it.cover }
|
||||
return paths.filter { it.isNotEmpty() && File(it).isFile }.distinct().map { AddedGameArt.Option(AddedGameArt.FOLDER, it, it) }
|
||||
}
|
||||
|
||||
fun choose(context: Context, id: Int, option: AddedGameArt.Option): Boolean {
|
||||
val folder = dir(context, id)
|
||||
val fresh = AddedGameArt.storeNew(folder, AddedGameArt.Slot.COVER, option) ?: return false
|
||||
AddedGameArt.dropOlder(folder, AddedGameArt.Slot.COVER, fresh)
|
||||
sourceFile(context, id).writeText(option.group + "|" + option.full)
|
||||
return true
|
||||
}
|
||||
|
||||
fun reset(context: Context, id: Int) {
|
||||
chosen(context, id)?.delete()
|
||||
sourceFile(context, id).delete()
|
||||
}
|
||||
|
||||
fun describe(context: Context, id: Int, root: File? = null): List<AddedGameArt.SlotState> {
|
||||
val own = chosen(context, id)
|
||||
val state = if (own != null) AddedGameArt.SlotState(AddedGameArt.Slot.COVER, own, AddedGameArt.FILE, true)
|
||||
else {
|
||||
val auto = if (root != null) Soundtrack.firstCover(context, root) else SoundtrackCollections.autoCover(id)
|
||||
AddedGameArt.SlotState(AddedGameArt.Slot.COVER, auto, if (auto != null) AddedGameArt.FOLDER else AddedGameArt.AUTO, false)
|
||||
}
|
||||
return listOf(state)
|
||||
}
|
||||
|
||||
fun clear(context: Context, id: Int) {
|
||||
dir(context, id).deleteRecursively()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,191 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.content.Context
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
import java.util.concurrent.Executors
|
||||
|
||||
object SoundtrackCollections {
|
||||
const val FAVORITES_ID = 2_000_000_000
|
||||
|
||||
class TrackRef(val path: String, val title: String, val artist: String, val album: String, val durationMs: Long, val cover: String = "")
|
||||
class Collection(val id: Int, val name: String, val tracks: List<TrackRef>)
|
||||
class Snapshot(val favorites: List<TrackRef>, val collections: List<Collection>)
|
||||
|
||||
private val state = mutableStateOf(Snapshot(emptyList(), emptyList()))
|
||||
private var loaded = false
|
||||
private val writer = Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-collections").apply { isDaemon = true } }
|
||||
|
||||
val snapshot: Snapshot get() = state.value
|
||||
|
||||
private fun file(context: Context) = File(context.filesDir, "soundtrack-collections.json")
|
||||
|
||||
internal fun toggled(list: List<TrackRef>, ref: TrackRef): List<TrackRef> =
|
||||
if (list.any { it.path == ref.path }) list.filterNot { it.path == ref.path } else list + ref
|
||||
|
||||
internal fun merged(list: List<TrackRef>, add: List<TrackRef>): List<TrackRef> {
|
||||
val have = list.mapTo(HashSet()) { it.path }
|
||||
return list + add.filter { have.add(it.path) }
|
||||
}
|
||||
|
||||
internal fun cleanName(raw: String): String = raw.trim().replace(Regex("\\s+"), " ")
|
||||
|
||||
internal fun nameTaken(collections: List<Collection>, name: String, except: Int? = null): Boolean =
|
||||
collections.any { it.id != except && it.name.equals(name, ignoreCase = true) }
|
||||
|
||||
internal fun nextId(collections: List<Collection>): Int =
|
||||
(collections.maxOfOrNull { it.id } ?: FAVORITES_ID).coerceAtLeast(FAVORITES_ID) + 1
|
||||
|
||||
private fun encode(s: Snapshot): String {
|
||||
fun refs(list: List<TrackRef>) = JSONArray().also { array ->
|
||||
list.forEach {
|
||||
array.put(
|
||||
JSONObject().put("path", it.path).put("title", it.title).put("artist", it.artist).put("album", it.album)
|
||||
.put("duration", it.durationMs).put("cover", it.cover),
|
||||
)
|
||||
}
|
||||
}
|
||||
val collections = JSONArray()
|
||||
s.collections.forEach { collections.put(JSONObject().put("id", it.id).put("name", it.name).put("tracks", refs(it.tracks))) }
|
||||
return JSONObject().put("favorites", refs(s.favorites)).put("collections", collections).toString()
|
||||
}
|
||||
|
||||
private fun decode(text: String): Snapshot {
|
||||
fun refs(array: JSONArray?): List<TrackRef> = if (array == null) emptyList() else List(array.length()) { i ->
|
||||
array.getJSONObject(i).let {
|
||||
TrackRef(it.getString("path"), it.optString("title"), it.optString("artist"), it.optString("album"), it.optLong("duration"), it.optString("cover"))
|
||||
}
|
||||
}
|
||||
val root = JSONObject(text)
|
||||
val collections = root.optJSONArray("collections")
|
||||
return Snapshot(
|
||||
refs(root.optJSONArray("favorites")),
|
||||
if (collections == null) emptyList() else List(collections.length()) { i ->
|
||||
collections.getJSONObject(i).let { Collection(it.getInt("id"), it.getString("name"), refs(it.optJSONArray("tracks"))) }
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun load(context: Context) {
|
||||
if (loaded) return
|
||||
loaded = true
|
||||
val f = file(context)
|
||||
if (f.isFile) runCatching { state.value = decode(f.readText()) }
|
||||
}
|
||||
|
||||
private fun commit(context: Context, next: Snapshot) {
|
||||
state.value = next
|
||||
val f = file(context)
|
||||
val json = encode(next)
|
||||
writer.execute {
|
||||
runCatching {
|
||||
val tmp = File(f.path + ".tmp")
|
||||
tmp.writeText(json)
|
||||
if (!tmp.renameTo(f)) tmp.delete()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun tracksOf(id: Int): List<TrackRef> =
|
||||
if (id == FAVORITES_ID) snapshot.favorites else snapshot.collections.firstOrNull { it.id == id }?.tracks.orEmpty()
|
||||
|
||||
fun isFavorite(path: String): Boolean = snapshot.favorites.any { it.path == path }
|
||||
|
||||
@Synchronized
|
||||
fun toggleFavorite(context: Context, ref: TrackRef) {
|
||||
load(context)
|
||||
val s = snapshot
|
||||
commit(context, Snapshot(toggled(s.favorites, ref), s.collections))
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun create(context: Context, rawName: String, tracks: List<TrackRef>): Int? {
|
||||
load(context)
|
||||
val s = snapshot
|
||||
val name = cleanName(rawName)
|
||||
if (name.isEmpty() || nameTaken(s.collections, name)) return null
|
||||
val id = nextId(s.collections)
|
||||
commit(context, Snapshot(s.favorites, s.collections + Collection(id, name, merged(emptyList(), tracks))))
|
||||
return id
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun rename(context: Context, id: Int, rawName: String): Boolean {
|
||||
load(context)
|
||||
val s = snapshot
|
||||
val name = cleanName(rawName)
|
||||
if (id == FAVORITES_ID || name.isEmpty() || nameTaken(s.collections, name, id)) return false
|
||||
commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, name, it.tracks) else it }))
|
||||
return true
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun delete(context: Context, id: Int) {
|
||||
load(context)
|
||||
val s = snapshot
|
||||
if (id == FAVORITES_ID) return
|
||||
commit(context, Snapshot(s.favorites, s.collections.filterNot { it.id == id }))
|
||||
SoundtrackCollectionArt.clear(context, id)
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun add(context: Context, id: Int, tracks: List<TrackRef>) {
|
||||
load(context)
|
||||
val s = snapshot
|
||||
if (id == FAVORITES_ID) commit(context, Snapshot(merged(s.favorites, tracks), s.collections))
|
||||
else commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, it.name, merged(it.tracks, tracks)) else it }))
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun remove(context: Context, id: Int, paths: Set<String>) {
|
||||
load(context)
|
||||
val s = snapshot
|
||||
if (id == FAVORITES_ID) commit(context, Snapshot(s.favorites.filterNot { it.path in paths }, s.collections))
|
||||
else commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, it.name, it.tracks.filterNot { t -> t.path in paths }) else it }))
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun reorder(context: Context, id: Int, ordered: List<String>) {
|
||||
load(context)
|
||||
val s = snapshot
|
||||
fun arrange(list: List<TrackRef>): List<TrackRef> {
|
||||
val byPath = list.associateBy { it.path }
|
||||
val placed = ordered.mapNotNull { byPath[it] }
|
||||
val named = ordered.toSet()
|
||||
val rest = list.filter { it.path !in named }
|
||||
return placed + rest
|
||||
}
|
||||
if (id == FAVORITES_ID) commit(context, Snapshot(arrange(s.favorites), s.collections))
|
||||
else commit(context, Snapshot(s.favorites, s.collections.map { if (it.id == id) Collection(id, it.name, arrange(it.tracks)) else it }))
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun refresh() {
|
||||
state.value = Snapshot(state.value.favorites, state.value.collections)
|
||||
}
|
||||
|
||||
internal fun autoCover(id: Int): File? = coverOf(tracksOf(id))
|
||||
|
||||
private fun coverOf(tracks: List<TrackRef>): File? =
|
||||
tracks.firstNotNullOfOrNull { t -> t.cover.takeIf { it.isNotEmpty() }?.let { File(it) }?.takeIf { it.isFile } }
|
||||
|
||||
private fun game(context: Context, id: Int, name: String, tracks: List<TrackRef>): Library.SteamGame = Library.SteamGame(
|
||||
appId = id, name = name, art = SoundtrackCollectionArt.chosen(context, id) ?: coverOf(tracks), library = Library.ADDED, gameId = id.toLong(),
|
||||
source = Library.SOURCE_COLLECTION, soundtrack = true,
|
||||
)
|
||||
|
||||
fun games(context: Context, favoritesLabel: String): List<Library.SteamGame> {
|
||||
val s = snapshot
|
||||
return listOf(game(context, FAVORITES_ID, favoritesLabel, s.favorites)) + s.collections.map { game(context, it.id, it.name, it.tracks) }
|
||||
}
|
||||
|
||||
fun album(context: Context, id: Int): Soundtrack.Album {
|
||||
val tracks = tracksOf(id).filter { File(it.path).isFile }.mapIndexed { i, t ->
|
||||
Soundtrack.Track(File(t.path), t.title, 1, i + 1, t.durationMs, t.artist)
|
||||
}
|
||||
return Soundtrack.Album(mapOf(1 to tracks), "", SoundtrackCollectionArt.chosen(context, id))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.content.Context
|
||||
|
||||
object SoundtrackIndex {
|
||||
class Hit(val ref: SoundtrackCollections.TrackRef, val game: Library.SteamGame)
|
||||
|
||||
private var cacheKey = ""
|
||||
private var cache: List<Hit> = emptyList()
|
||||
|
||||
private fun fingerprint(dir: java.io.File?): Long =
|
||||
if (dir == null) 0L else Soundtrack.audioFiles(dir).fold(17L) { h, f -> 31 * (31 * (31 * h + f.path.hashCode()) + f.length()) + f.lastModified() }
|
||||
|
||||
fun build(context: Context, games: List<Library.SteamGame>): List<Hit> {
|
||||
val roots = games.filter { it.gameFiles != null }
|
||||
val key = roots.joinToString("|") { "${it.appId}:${it.gameFiles?.path}:${it.art?.path}:${fingerprint(it.gameFiles)}" }
|
||||
synchronized(this) { if (key == cacheKey) return cache }
|
||||
val hits = roots.flatMap { g ->
|
||||
val dir = g.gameFiles ?: return@flatMap emptyList()
|
||||
val album = Soundtrack.load(context, dir, g.art)
|
||||
val cover = (g.art ?: album.cover)?.path.orEmpty()
|
||||
album.tracks.map { t ->
|
||||
Hit(SoundtrackCollections.TrackRef(t.file.path, t.title, t.artist.ifBlank { album.artist }, g.name, t.durationMs, cover), g)
|
||||
}
|
||||
}
|
||||
synchronized(this) {
|
||||
cacheKey = key
|
||||
cache = hits
|
||||
}
|
||||
return hits
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.content.Context
|
||||
import androidx.compose.runtime.mutableIntStateOf
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
import java.util.concurrent.Executors
|
||||
|
||||
object SoundtrackOrder {
|
||||
private val changes = mutableIntStateOf(0)
|
||||
private var cache: Map<String, List<String>>? = null
|
||||
private val writer = Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-order").apply { isDaemon = true } }
|
||||
|
||||
val version: Int get() = changes.intValue
|
||||
|
||||
private fun file(context: Context) = File(context.filesDir, "soundtrack-order.json")
|
||||
|
||||
@Synchronized
|
||||
private fun read(context: Context): Map<String, List<String>> {
|
||||
cache?.let { return it }
|
||||
val out = HashMap<String, List<String>>()
|
||||
val f = file(context)
|
||||
if (f.isFile) runCatching {
|
||||
val json = JSONObject(f.readText())
|
||||
for (key in json.keys()) {
|
||||
val array = json.getJSONArray(key)
|
||||
out[key] = List(array.length()) { array.getString(it) }
|
||||
}
|
||||
}
|
||||
cache = out
|
||||
return out
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun set(context: Context, root: File, paths: List<String>) {
|
||||
val next = HashMap(read(context))
|
||||
next[root.path] = paths
|
||||
cache = next
|
||||
val body = JSONObject().also { json -> next.forEach { (k, v) -> json.put(k, JSONArray(v)) } }.toString()
|
||||
val target = file(context)
|
||||
writer.execute {
|
||||
val tmp = File(target.path + ".tmp")
|
||||
runCatching {
|
||||
tmp.writeText(body)
|
||||
if (!tmp.renameTo(target)) tmp.delete()
|
||||
}
|
||||
}
|
||||
changes.intValue++
|
||||
}
|
||||
|
||||
internal fun ordered(disc: Map<Int, List<Soundtrack.Track>>, order: List<String>): Map<Int, List<Soundtrack.Track>> {
|
||||
if (order.isEmpty()) return disc
|
||||
val index = HashMap<String, Int>()
|
||||
order.forEachIndexed { i, p -> index.putIfAbsent(p, i) }
|
||||
return disc.mapValues { (_, list) ->
|
||||
list.sortedBy { index[it.file.path] ?: Int.MAX_VALUE }.mapIndexed { i, t ->
|
||||
Soundtrack.Track(t.file, t.title, t.disc, i + 1, t.durationMs, t.artist, t.discLabel)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun apply(context: Context, root: File, disc: Map<Int, List<Soundtrack.Track>>): Map<Int, List<Soundtrack.Track>> {
|
||||
val order = read(context)[root.path] ?: return disc
|
||||
return ordered(disc, order)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.app.Activity
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.ShortcutInfo
|
||||
import android.content.pm.ShortcutManager
|
||||
import android.graphics.drawable.Icon
|
||||
import android.net.Uri
|
||||
import android.widget.Toast
|
||||
import com.droiddeck.launcher.FrontEndActivity
|
||||
import com.droiddeck.launcher.LauncherIcon
|
||||
import com.droiddeck.launcher.R
|
||||
|
||||
object SoundtrackShortcuts {
|
||||
private val linkPattern = Regex("droiddeck://soundtrack/(-?[0-9]{1,11})")
|
||||
|
||||
fun uri(appId: Int): String = "droiddeck://soundtrack/$appId"
|
||||
|
||||
fun parse(link: String?): Int? = link?.let { linkPattern.matchEntire(it)?.groupValues?.get(1)?.toIntOrNull() }
|
||||
|
||||
fun read(intent: Intent): Int? = if (intent.action == Intent.ACTION_VIEW) parse(intent.dataString) else null
|
||||
|
||||
private fun info(context: Context, game: Library.SteamGame): ShortcutInfo {
|
||||
val name = game.name.ifBlank { context.getString(R.string.app_name) }
|
||||
val icon = GameShortcuts.iconBitmap(game)?.let(Icon::createWithBitmap) ?: Icon.createWithResource(context, R.mipmap.ic_launcher)
|
||||
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(uri(game.appId)), context, FrontEndActivity::class.java)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
|
||||
return ShortcutInfo.Builder(context, "soundtrack:${game.appId}")
|
||||
.setActivity(LauncherIcon.activity(context))
|
||||
.setShortLabel(name.take(40)).setLongLabel(name).setIcon(icon).setIntent(intent).build()
|
||||
}
|
||||
|
||||
fun pin(activity: Activity, game: Library.SteamGame) {
|
||||
val manager = activity.getSystemService(ShortcutManager::class.java)
|
||||
val requested = runCatching {
|
||||
manager.isRequestPinShortcutSupported && manager.requestPinShortcut(info(activity, game), null)
|
||||
}.getOrDefault(false)
|
||||
if (!requested) Toast.makeText(activity, R.string.game_shortcut_unsupported, Toast.LENGTH_LONG).show()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
object SoundtrackTracks {
|
||||
enum class Sort { DEFAULT, TITLE_ASC, TITLE_DESC, LONGEST, SHORTEST }
|
||||
|
||||
fun <T> sort(items: List<T>, sort: Sort, title: (T) -> String, duration: (T) -> Long): List<T> = when (sort) {
|
||||
Sort.DEFAULT -> items
|
||||
Sort.TITLE_ASC -> items.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER, title))
|
||||
Sort.TITLE_DESC -> items.sortedWith(compareByDescending(String.CASE_INSENSITIVE_ORDER, title))
|
||||
Sort.LONGEST -> items.sortedByDescending(duration)
|
||||
Sort.SHORTEST -> items.sortedBy(duration)
|
||||
}
|
||||
|
||||
fun matches(query: String, vararg fields: String): Boolean {
|
||||
val words = query.trim().lowercase().split(' ').filter { it.isNotEmpty() }
|
||||
if (words.isEmpty()) return true
|
||||
val haystack = fields.map { it.lowercase() }
|
||||
return words.all { word -> haystack.any { it.contains(word) } }
|
||||
}
|
||||
|
||||
fun rank(query: String, title: String): Int {
|
||||
val q = query.trim().lowercase()
|
||||
val t = title.lowercase()
|
||||
return when {
|
||||
t == q -> 0
|
||||
t.startsWith(q) -> 1
|
||||
else -> 2
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -24,11 +24,7 @@ object SteamGameArt {
|
||||
val icon = chosenFile(context, game.appId, AddedGameArt.Slot.ICON)
|
||||
val logo = chosenFile(context, game.appId, AddedGameArt.Slot.LOGO)
|
||||
if (cover == null && hero == null && icon == null && logo == null) return game
|
||||
return Library.SteamGame(
|
||||
game.appId, game.name, cover ?: game.art, game.library, game.gameId,
|
||||
hero ?: game.hero, game.lastPlayed, game.gameFiles, game.protonPrefix, icon ?: game.icon, game.source, game.storeId,
|
||||
logo ?: game.logo,
|
||||
)
|
||||
return game.withArt(cover ?: game.art, hero ?: game.hero, icon ?: game.icon, logo ?: game.logo)
|
||||
}
|
||||
|
||||
fun chosenSource(context: Context, appId: Int, slot: AddedGameArt.Slot): Pair<String, String> {
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.droiddeck.launcher.frontend
|
||||
|
||||
import android.content.Context
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
|
||||
object SteamInputOverride {
|
||||
private const val CONFIG_KEY = "UseSteamControllerConfig"
|
||||
private const val DEFAULT_VALUE = "1"
|
||||
|
||||
enum class Mode(val value: String?) {
|
||||
DEFAULT(null), ENABLED("2"), DISABLED("0");
|
||||
|
||||
companion object {
|
||||
fun from(value: String): Mode? = when (value) {
|
||||
DEFAULT_VALUE -> DEFAULT
|
||||
"2" -> ENABLED
|
||||
"0" -> DISABLED
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum class Saved { YES, NO, RUNNING }
|
||||
|
||||
fun current(context: Context, appId: Int): Mode? =
|
||||
SteamLaunchOptions.steamAppSetting(
|
||||
SessionPrefs.activeSteamRoot(context), appId, CONFIG_KEY, DEFAULT_VALUE,
|
||||
)?.let(Mode::from)
|
||||
|
||||
fun set(context: Context, appId: Int, mode: Mode, shown: Mode): Saved {
|
||||
if (SessionState.running) return Saved.RUNNING
|
||||
val saved = SteamLaunchOptions.writeSteamAppSetting(
|
||||
SessionPrefs.activeSteamRoot(context), appId, CONFIG_KEY,
|
||||
shown.value ?: DEFAULT_VALUE, mode.value, DEFAULT_VALUE,
|
||||
)
|
||||
return if (saved) Saved.YES else Saved.NO
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,8 @@ import java.nio.file.StandardCopyOption
|
||||
object SteamLaunchOptions {
|
||||
private const val TAG = "SteamLaunchOptions"
|
||||
private val STEAM = listOf("UserLocalConfigStore", "Software", "Valve", "Steam")
|
||||
// Steam keeps per-game settings such as UseSteamControllerConfig in the root apps section, and launch options under Software/Valve/Steam.
|
||||
private val ROOT = listOf("UserLocalConfigStore")
|
||||
|
||||
fun current(context: Context, appId: Int): String? =
|
||||
SteamLiveShortcuts.launchOptions(context, appId.toLong()) ?: steam(SessionPrefs.activeSteamRoot(context), appId)
|
||||
@@ -36,13 +38,38 @@ object SteamLaunchOptions {
|
||||
val config = AddedGames.accountConfig(steamHome) ?: return null
|
||||
val text = runCatching { File(config, "localconfig.vdf").readText() }.getOrNull() ?: return null
|
||||
if (section(text, STEAM) == null) return null
|
||||
return launchOptions(text, appId).orEmpty()
|
||||
return appValue(text, appId, "LaunchOptions").orEmpty()
|
||||
}
|
||||
|
||||
internal fun write(steamHome: File, appId: Int, options: String): Boolean {
|
||||
val config = AddedGames.accountConfig(steamHome)?.let { File(it, "localconfig.vdf") } ?: return false
|
||||
val text = runCatching { config.readText() }.getOrNull() ?: return false
|
||||
val updated = withLaunchOptions(text, appId, options) ?: return false
|
||||
return writeConfig(config, text, updated)
|
||||
}
|
||||
|
||||
internal fun steamAppSetting(steamHome: File, appId: Int, key: String, default: String): String? {
|
||||
val config = AddedGames.accountConfig(steamHome) ?: return null
|
||||
val text = runCatching { File(config, "localconfig.vdf").readText() }.getOrNull() ?: return null
|
||||
if (section(text, ROOT) == null) return null
|
||||
return settingValue(text, appId, key) ?: default
|
||||
}
|
||||
|
||||
private fun settingValue(text: String, appId: Int, key: String): String? =
|
||||
appValue(text, appId, key, ROOT) ?: appValue(text, appId, key, STEAM)
|
||||
|
||||
internal fun writeSteamAppSetting(
|
||||
steamHome: File, appId: Int, key: String, expected: String, value: String?, default: String,
|
||||
): Boolean {
|
||||
val config = AddedGames.accountConfig(steamHome)?.let { File(it, "localconfig.vdf") } ?: return false
|
||||
val text = runCatching { config.readText() }.getOrNull() ?: return false
|
||||
if (section(text, ROOT) == null || (settingValue(text, appId, key) ?: default) != expected) return false
|
||||
val updated = (if (value == null) withoutAppValue(text, appId, key, ROOT) else withAppValue(text, appId, key, value, ROOT))
|
||||
?.let { withoutAppValue(it, appId, key, STEAM) } ?: return false
|
||||
return writeConfig(config, text, updated)
|
||||
}
|
||||
|
||||
private fun writeConfig(config: File, text: String, updated: String): Boolean {
|
||||
if (updated == text) return true
|
||||
val staged = File(config.parentFile, config.name + ".staged")
|
||||
return try {
|
||||
@@ -55,36 +82,57 @@ object SteamLaunchOptions {
|
||||
true
|
||||
} catch (e: Exception) {
|
||||
staged.delete()
|
||||
Log.w(TAG, "could not write launch options to ${config.path}", e)
|
||||
Log.w(TAG, "could not write Steam app settings to ${config.path}", e)
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
internal fun launchOptions(text: String, appId: Int): String? {
|
||||
val app = section(text, STEAM + "apps" + appId.toString()) ?: return null
|
||||
return entries(text, app.valueStart, app.end).firstOrNull { !it.section && it.key.equals("LaunchOptions", true) }
|
||||
return appValue(text, appId, "LaunchOptions")
|
||||
}
|
||||
|
||||
private fun appValue(text: String, appId: Int, key: String, base: List<String> = STEAM): String? {
|
||||
val app = section(text, base + "apps" + appId.toString()) ?: return null
|
||||
return entries(text, app.valueStart, app.end).firstOrNull { !it.section && it.key.equals(key, true) }
|
||||
?.let { unescape(text.substring(it.valueStart + 1, it.end)) }
|
||||
}
|
||||
|
||||
internal fun withLaunchOptions(text: String, appId: Int, options: String): String? {
|
||||
internal fun withLaunchOptions(text: String, appId: Int, options: String): String? =
|
||||
withAppValue(text, appId, "LaunchOptions", options)
|
||||
|
||||
private fun withAppValue(text: String, appId: Int, key: String, rawValue: String, base: List<String> = STEAM): String? {
|
||||
val newline = if (text.contains("\r\n")) "\r\n" else "\n"
|
||||
var updated = text
|
||||
var path = STEAM
|
||||
for (key in listOf("apps", appId.toString())) {
|
||||
updated = withSection(updated, section(updated, path) ?: return null, key, newline) ?: return null
|
||||
path = path + key
|
||||
var path = base
|
||||
for (pathPart in listOf("apps", appId.toString())) {
|
||||
updated = withSection(updated, section(updated, path) ?: return null, pathPart, newline) ?: return null
|
||||
path = path + pathPart
|
||||
}
|
||||
val app = section(updated, path) ?: return null
|
||||
val value = "\"" + escape(options) + "\""
|
||||
entries(updated, app.valueStart, app.end).firstOrNull { !it.section && it.key.equals("LaunchOptions", true) }?.let {
|
||||
val value = "\"" + escape(rawValue) + "\""
|
||||
entries(updated, app.valueStart, app.end).firstOrNull { !it.section && it.key.equals(key, true) }?.let {
|
||||
return updated.replaceRange(it.valueStart, it.end + 1, value)
|
||||
}
|
||||
val lineStart = closingLine(updated, app) ?: return null
|
||||
val indent = updated.substring(lineStart, app.end) + "\t"
|
||||
return updated.substring(0, lineStart) + indent + "\"LaunchOptions\"\t\t" + value + newline + updated.substring(lineStart)
|
||||
return updated.substring(0, lineStart) + indent + "\"${escape(key)}\"\t\t" + value + newline + updated.substring(lineStart)
|
||||
}
|
||||
|
||||
private class Entry(val key: String, val valueStart: Int, val end: Int, val section: Boolean)
|
||||
private fun withoutAppValue(text: String, appId: Int, key: String, base: List<String> = STEAM): String {
|
||||
val app = section(text, base + "apps" + appId.toString()) ?: return text
|
||||
val entry = entries(text, app.valueStart, app.end).firstOrNull { !it.section && it.key.equals(key, true) } ?: return text
|
||||
val lineStart = text.lastIndexOf('\n', entry.start - 1) + 1
|
||||
val lineEnd = text.indexOf('\n', entry.end + 1).let { if (it < 0) text.length else it }
|
||||
val onlyEntryOnLine = text.substring(lineStart, entry.start).all(Char::isWhitespace) &&
|
||||
text.substring(entry.end + 1, lineEnd).all(Char::isWhitespace)
|
||||
return if (onlyEntryOnLine) {
|
||||
text.removeRange(lineStart, if (lineEnd < text.length) lineEnd + 1 else lineEnd)
|
||||
} else {
|
||||
text.removeRange(entry.start, entry.end + 1)
|
||||
}
|
||||
}
|
||||
|
||||
private class Entry(val key: String, val start: Int, val valueStart: Int, val end: Int, val section: Boolean)
|
||||
|
||||
private fun section(text: String, path: List<String>): Entry? {
|
||||
var found: Entry? = null
|
||||
@@ -98,18 +146,27 @@ object SteamLaunchOptions {
|
||||
private fun entries(text: String, open: Int, close: Int): List<Entry> {
|
||||
val found = ArrayList<Entry>()
|
||||
var key: String? = null
|
||||
var keyStart = -1
|
||||
var i = open + 1
|
||||
while (i < close) {
|
||||
when {
|
||||
text[i] == '"' -> {
|
||||
val end = stringEnd(text, i) ?: return found
|
||||
if (key == null) key = unescape(text.substring(i + 1, end)) else { found += Entry(key, i, end, false); key = null }
|
||||
if (key == null) {
|
||||
key = unescape(text.substring(i + 1, end))
|
||||
keyStart = i
|
||||
} else {
|
||||
found += Entry(key, keyStart, i, end, false)
|
||||
key = null
|
||||
keyStart = -1
|
||||
}
|
||||
i = end + 1
|
||||
}
|
||||
text[i] == '{' -> {
|
||||
val end = sectionEnd(text, i) ?: return found
|
||||
key?.let { found += Entry(it, i, end, true) }
|
||||
key?.let { found += Entry(it, keyStart, i, end, true) }
|
||||
key = null
|
||||
keyStart = -1
|
||||
i = end + 1
|
||||
}
|
||||
text.startsWith("//", i) -> i = text.indexOf('\n', i).let { if (it < 0) close else it }
|
||||
|
||||
@@ -563,7 +563,7 @@ object Glasses {
|
||||
val device = selected?.first
|
||||
val m = selected?.second
|
||||
val controllable = m?.let(::canOpenModel) == true
|
||||
val permitted = controllable && device != null && (m === XrealModel || usb.hasPermission(device))
|
||||
val permitted = controllable && device != null && (m is XrealModel || usb.hasPermission(device))
|
||||
val identity = device?.let {
|
||||
GlassesModeState.Device(it.productId, if (permitted) runCatching { it.serialNumber }.getOrNull() else null)
|
||||
}
|
||||
@@ -614,9 +614,9 @@ object Glasses {
|
||||
sbs = sbsByDisplay,
|
||||
switching3d = modeState.pendingStereo,
|
||||
brightnessMax = m?.brightnessMax ?: 8, volumeMax = m?.volumeMax ?: 8,
|
||||
sunblock = if (m === XrealModel) it.sunblock else _settings.value.sunblock ?: it.sunblock,
|
||||
sunblock = if (m is XrealModel) it.sunblock else _settings.value.sunblock ?: it.sunblock,
|
||||
hardwareControls = m?.hardwareControls == true &&
|
||||
(device?.vendorId == VitureProtocol.VENDOR_ID || m === XrealModel || m is RokidModel),
|
||||
(device?.vendorId == VitureProtocol.VENDOR_ID || m is XrealModel || m is RokidModel),
|
||||
supportsDisplayModeControl = m?.supportsDisplayModeControl == true,
|
||||
hasSunblock = m?.hasSunblock == true,
|
||||
diagonalFovDeg = m?.diagonalFovDeg ?: 46f,
|
||||
@@ -624,7 +624,7 @@ object Glasses {
|
||||
noSignal = noSignal,
|
||||
sbs90 = m?.sbs90 == true,
|
||||
rates2d = m?.rates2d ?: listOf(60, 90, 120),
|
||||
experimental = m === XrealModel || (m is VitureProtocol.Model && m.family == VitureProtocol.Family.PRO2 && !m.needsSdk),
|
||||
experimental = m is XrealModel || (m is VitureProtocol.Model && m.family == VitureProtocol.Family.PRO2 && !m.needsSdk),
|
||||
supportsScreen3dof = link?.hasImu == true,
|
||||
supports30Hz = display?.let(::supports30Hz) == true,
|
||||
supportsSpatial = (link as? VitureSdkLink)?.isCarina == true,
|
||||
@@ -660,8 +660,8 @@ object Glasses {
|
||||
else VitureSdk.marketName(device.productId)?.let(VitureProtocol::sdkModel)
|
||||
?: VitureProtocol.model(device.productId, name)
|
||||
}
|
||||
else if (XrealModel.matches(device.vendorId, device.productId)) XrealModel
|
||||
else RokidModel.model(device.vendorId, device.productId, name)
|
||||
else XrealModel.model(device.vendorId, device.productId)
|
||||
?: RokidModel.model(device.vendorId, device.productId, name)
|
||||
?: RayNeoModel.model(device.vendorId, device.productId, name)
|
||||
}
|
||||
|
||||
@@ -729,8 +729,8 @@ object Glasses {
|
||||
VitureSdkLink.open(usb, device, File(app.noBackupFilesDir, "viture"), sdkListener(generation),
|
||||
(model as? VitureProtocol.Model)?.family, spatial)
|
||||
} else VitureLink.open(usb, device, linkListener(generation))
|
||||
} else if (model === XrealModel) {
|
||||
XrealLink.open(app, xrealListener(generation))
|
||||
} else if (model is XrealModel) {
|
||||
XrealLink.open(app, model as XrealModel, xrealListener(generation))
|
||||
} else if (model is RokidModel) {
|
||||
RokidLink.open(usb, device, rokidListener(generation))
|
||||
} else {
|
||||
|
||||
@@ -10,6 +10,7 @@ import java.util.concurrent.atomic.AtomicReference
|
||||
internal class XrealLink internal constructor(
|
||||
private val connector: XrealConnector,
|
||||
private val listener: Listener,
|
||||
private val model: XrealModel = XrealModel.ONE_S,
|
||||
) : GlassesLink {
|
||||
interface Listener {
|
||||
fun onReady()
|
||||
@@ -29,7 +30,8 @@ internal class XrealLink internal constructor(
|
||||
private val worker = Thread(::run, "xreal-control").apply { isDaemon = true; start() }
|
||||
|
||||
companion object {
|
||||
fun open(context: Context, listener: Listener) = XrealLink(AndroidXrealConnector(context), listener)
|
||||
fun open(context: Context, model: XrealModel, listener: Listener) =
|
||||
XrealLink(AndroidXrealConnector(context), listener, model)
|
||||
}
|
||||
|
||||
override fun send(msgId: Int, payload: ByteArray): Boolean {
|
||||
@@ -43,9 +45,10 @@ internal class XrealLink internal constructor(
|
||||
if (msgId == VitureProtocol.MSG_GET_IMU) return true
|
||||
val valid = when (msgId) {
|
||||
VitureProtocol.MSG_GET_DISPLAY -> true
|
||||
VitureProtocol.MSG_DISPLAY -> value in 2..5 || value == XrealModel.NATIVE_60HZ
|
||||
VitureProtocol.MSG_BRIGHTNESS -> value in 0..9
|
||||
VitureProtocol.MSG_FILM -> value in 0..1
|
||||
VitureProtocol.MSG_DISPLAY -> if (model.stereoOnlyControl) value == 5 || value == XrealModel.NATIVE_60HZ
|
||||
else value in 2..5 || value == XrealModel.NATIVE_60HZ
|
||||
VitureProtocol.MSG_BRIGHTNESS -> !model.stereoOnlyControl && value in 0..9
|
||||
VitureProtocol.MSG_FILM -> !model.stereoOnlyControl && value in 0..1
|
||||
else -> false
|
||||
}
|
||||
return valid && commands.offer(Command(msgId, value))
|
||||
@@ -61,12 +64,12 @@ internal class XrealLink internal constructor(
|
||||
channels = connector.connect()
|
||||
connection.set(channels)
|
||||
if (!running) break
|
||||
val control = XrealControl(channels)
|
||||
val control = XrealControl(channels, stereoOnly = model.stereoOnlyControl)
|
||||
listener.onValue(VitureProtocol.MSG_GET_DISPLAY, control.display())
|
||||
val current = channels
|
||||
reports = Thread({
|
||||
try {
|
||||
var filter = XrealOrientationFilter()
|
||||
var filter = XrealOrientationFilter(model.flipsYz)
|
||||
var wasTracking = false
|
||||
var lastSensor = System.nanoTime()
|
||||
while (running && connection.get() === current) {
|
||||
@@ -75,7 +78,7 @@ internal class XrealLink internal constructor(
|
||||
if (sample != null) {
|
||||
lastSensor = System.nanoTime()
|
||||
val enabled = tracking
|
||||
if (enabled && !wasTracking) filter = XrealOrientationFilter()
|
||||
if (enabled && !wasTracking) filter = XrealOrientationFilter(model.flipsYz)
|
||||
wasTracking = enabled
|
||||
if (enabled) filter.update(sample)?.let {
|
||||
if (running && ready && tracking && connection.get() === current)
|
||||
@@ -149,7 +152,11 @@ internal class XrealLink internal constructor(
|
||||
}
|
||||
}
|
||||
|
||||
internal class XrealControl(private val channels: XrealChannels, private val settleDelayMs: Long = 150) {
|
||||
internal class XrealControl(
|
||||
private val channels: XrealChannels,
|
||||
private val settleDelayMs: Long = 150,
|
||||
private val stereoOnly: Boolean = false,
|
||||
) {
|
||||
private var transaction = 0
|
||||
private fun exchange(command: Int, value: Int? = null): ByteArray {
|
||||
transaction = if (transaction == Int.MAX_VALUE) 1 else transaction + 1
|
||||
@@ -163,26 +170,42 @@ internal class XrealControl(private val channels: XrealChannels, private val set
|
||||
throw IOException("XREAL control response was not received")
|
||||
}
|
||||
fun display(): Int {
|
||||
if (stereoOnly) return stereoDisplay()
|
||||
val reply = exchange(XrealProtocol.GET_DISPLAY)
|
||||
return XrealProtocol.numeric(reply)?.takeIf { it in 2..5 || it == XrealModel.NATIVE_60HZ }
|
||||
?: throw IOException("Unsupported XREAL display response: ${reply.take(32).joinToString("") { "%02x".format(it) }}")
|
||||
}
|
||||
private fun stereoDisplay(): Int {
|
||||
val reply = exchange(XrealProtocol.GET_INPUT)
|
||||
return when {
|
||||
XrealProtocol.acknowledged(reply) -> XrealModel.NATIVE_60HZ
|
||||
else -> when (XrealProtocol.numeric(reply)) {
|
||||
0 -> XrealModel.NATIVE_60HZ
|
||||
1 -> 5
|
||||
else -> throw IOException("Unsupported XREAL stereo response: ${reply.take(32).joinToString("") { "%02x".format(it) }}")
|
||||
}
|
||||
}
|
||||
}
|
||||
fun changeDisplay(mode: Int): Int {
|
||||
val stereo = mode == 5
|
||||
set(XrealProtocol.SET_INPUT, if (stereo) 1 else 0)
|
||||
val current = awaitDisplay { (it == 5) == stereo }
|
||||
if (current == mode) return current
|
||||
if (current == mode || stereoOnly) return current
|
||||
set(XrealProtocol.SET_DISPLAY, mode)
|
||||
return awaitDisplay { it == mode }
|
||||
}
|
||||
private fun awaitDisplay(matches: (Int) -> Boolean): Int {
|
||||
val deadline = System.nanoTime() + 8_000_000_000L
|
||||
repeat(40) {
|
||||
val reply = exchange(XrealProtocol.GET_DISPLAY)
|
||||
val value = XrealProtocol.numeric(reply)
|
||||
if (value != null && matches(value)) return value
|
||||
if (value == null && !XrealProtocol.acknowledged(reply))
|
||||
throw IOException("Invalid XREAL display transition response")
|
||||
if (stereoOnly) {
|
||||
stereoDisplay().let { if (matches(it)) return it }
|
||||
} else {
|
||||
val reply = exchange(XrealProtocol.GET_DISPLAY)
|
||||
val value = XrealProtocol.numeric(reply)
|
||||
if (value != null && matches(value)) return value
|
||||
if (value == null && !XrealProtocol.acknowledged(reply))
|
||||
throw IOException("Invalid XREAL display transition response")
|
||||
}
|
||||
if (System.nanoTime() > deadline) throw IOException("XREAL display transition timed out")
|
||||
Thread.sleep(settleDelayMs)
|
||||
}
|
||||
|
||||
@@ -1,25 +1,63 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
object XrealModel : GlassesModel {
|
||||
const val VENDOR_ID = 0x3318
|
||||
const val PRODUCT_1S = 0x043e
|
||||
const val NATIVE_60HZ = 29
|
||||
override val name = "XREAL 1S"
|
||||
internal class XrealModel private constructor(
|
||||
override val name: String,
|
||||
val family: Family,
|
||||
override val diagonalFovDeg: Float,
|
||||
) : GlassesModel {
|
||||
enum class Family {
|
||||
ONE_S,
|
||||
ONE,
|
||||
AURA,
|
||||
}
|
||||
|
||||
override val controllable = true
|
||||
override val brightnessMax = 9
|
||||
override val volumeMax = 0
|
||||
override val hasSunblock = true
|
||||
override val diagonalFovDeg = 52f
|
||||
override val hasSunblock get() = family == Family.ONE_S
|
||||
override val hardwareControls get() = family == Family.ONE_S
|
||||
override val sbs90 = false
|
||||
override val rates2d get() = if (family == Family.ONE_S) super.rates2d else listOf(60)
|
||||
|
||||
fun matches(vid: Int, pid: Int) = vid == VENDOR_ID && pid == PRODUCT_1S
|
||||
fun isDisplay(name: String) = name.contains("XREAL", ignoreCase = true)
|
||||
// Only the 1S has been exercised with SET_DISPLAY; the Aura is known to reboot on an unexpected index.
|
||||
val stereoOnlyControl get() = family != Family.ONE_S
|
||||
|
||||
// The Aura reports x right, y up, z back; the rest of the One family is a half turn about x from it.
|
||||
val flipsYz get() = family != Family.AURA
|
||||
|
||||
override fun mode(hz: Int, sbs: Boolean) = when {
|
||||
sbs -> 5
|
||||
stereoOnlyControl -> NATIVE_60HZ
|
||||
hz >= 120 -> 4
|
||||
hz >= 90 -> 3
|
||||
else -> NATIVE_60HZ
|
||||
}
|
||||
override fun modeForStep(step: Int): Int? = null
|
||||
|
||||
override fun toString() = name
|
||||
|
||||
companion object {
|
||||
const val VENDOR_ID = 0x3318
|
||||
const val PRODUCT_1S = 0x043e
|
||||
const val NATIVE_60HZ = 29
|
||||
|
||||
val ONE_S = XrealModel("XREAL 1S", Family.ONE_S, 52f)
|
||||
val ONE = XrealModel("XREAL One", Family.ONE, 50f)
|
||||
val ONE_PRO = XrealModel("XREAL One Pro", Family.ONE, 57f)
|
||||
val ONE_PRO_PLUS = XrealModel("XREAL One Pro+", Family.ONE, 57f)
|
||||
val AURA = XrealModel("XREAL Aura", Family.AURA, 70f)
|
||||
|
||||
// The odd product ids one below these are the glasses' recovery mode.
|
||||
private val products = mapOf(
|
||||
PRODUCT_1S to ONE_S,
|
||||
0x0438 to ONE,
|
||||
0x0436 to ONE_PRO,
|
||||
0x0444 to ONE_PRO_PLUS,
|
||||
0x043a to AURA,
|
||||
)
|
||||
|
||||
fun model(vid: Int, pid: Int): XrealModel? = if (vid == VENDOR_ID) products[pid] else null
|
||||
fun matches(vid: Int, pid: Int) = model(vid, pid) != null
|
||||
fun isDisplay(name: String) = name.contains("XREAL", ignoreCase = true)
|
||||
}
|
||||
}
|
||||
@@ -2,12 +2,13 @@ package com.droiddeck.launcher.glasses
|
||||
|
||||
import kotlin.math.abs
|
||||
|
||||
internal class XrealOrientationFilter {
|
||||
internal class XrealOrientationFilter(private val flipYz: Boolean = true) {
|
||||
private val fusion = ImuFusion()
|
||||
|
||||
fun update(sample: XrealProtocol.Sample): FloatArray? = fusion.update(sample.timeNs,
|
||||
Vec3(sample.accel.x, -sample.accel.y, -sample.accel.z),
|
||||
Vec3(sample.gyro.x, -sample.gyro.y, -sample.gyro.z))
|
||||
sample.accel.headAxes(), sample.gyro.headAxes())
|
||||
|
||||
private fun Vec3.headAxes() = if (flipYz) Vec3(x, -y, -z) else this
|
||||
}
|
||||
|
||||
internal class ImuFusion {
|
||||
|
||||
@@ -13,6 +13,7 @@ internal object XrealProtocol {
|
||||
const val REPORT = 0x2836
|
||||
const val GET_DISPLAY = 0x275e
|
||||
const val SET_DISPLAY = 0x275f
|
||||
const val GET_INPUT = 0x2821
|
||||
const val SET_INPUT = 0x2822
|
||||
const val SET_BRIGHTNESS = 0x271c
|
||||
const val SET_DIMMER = 0x2727
|
||||
|
||||
@@ -145,16 +145,22 @@ object DeviceInfo {
|
||||
private fun drivers(context: Context, gpu: GpuInfo) = Section("Drivers DroidDeck uses", buildList<Pair<String, String>> {
|
||||
add("Driver mode", SessionPrefs.gpuDriverMode(context))
|
||||
val turnip = TurnipDriver(context)
|
||||
val choice = SessionPrefs.androidDriver(context).ifEmpty { turnip.autoId() }
|
||||
val choice = turnip.effectiveId()
|
||||
val powerVr = gpu.family == GpuInfo.Family.POWERVR
|
||||
add("Display driver", if (choice == "system") builtinDriverLabel(powerVr, runtime = false)
|
||||
else "${turnip.displayName(choice)} ${turnip.driverVersion(choice)}".trim())
|
||||
val linux = LinuxVulkanDriverManager(context)
|
||||
val id = SessionPrefs.linuxDriver(context)
|
||||
add("Game driver", if (id.isEmpty()) builtinDriverLabel(powerVr, runtime = true) else "${linux.getDriverName(id)} ${linux.getDriverVersion(id)}".trim())
|
||||
add("Game driver", hostRoute(context) ?: if (id.isEmpty()) builtinDriverLabel(powerVr, runtime = true) else "${linux.getDriverName(id)} ${linux.getDriverVersion(id)}".trim())
|
||||
if (gpu.oneUi8Gen2) add("Note", "One UI on an 8 Gen 2: needs the OneUI Turnip build")
|
||||
})
|
||||
|
||||
internal fun hostRoute(context: Context): String? = when {
|
||||
com.droiddeck.launcher.session.VenusComponent.wanted(context) -> "Mali (Venus)"
|
||||
com.droiddeck.launcher.core.DeviceSupport.vkBridge(context) -> "the Mali bridge"
|
||||
else -> null
|
||||
}
|
||||
|
||||
/** Shared by the device card and the session report, which are written in English. */
|
||||
internal fun builtinDriverLabel(powerVr: Boolean, runtime: Boolean): String = when {
|
||||
powerVr -> "System PowerVR"
|
||||
|
||||
@@ -28,12 +28,38 @@ object FrameGen {
|
||||
|
||||
fun engine(context: Context): String = mode(context).engine
|
||||
|
||||
fun mode(context: Context): Mode {
|
||||
fun mode(context: Context): Mode = mode(context, null)
|
||||
|
||||
fun mode(context: Context, appId: String?): Mode {
|
||||
val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
|
||||
val engine = prefs.getString("engine", ENGINE_OFF).let { if (it == LEGACY_ENGINE_WINFG) ENGINE_DDFG else it ?: ENGINE_OFF }
|
||||
val target = prefs.getInt("target", 0)
|
||||
val gamePrefix = appId?.takeIf { it.isNotBlank() }?.let { "game.$it." }
|
||||
?.takeIf { prefs.contains(it + "engine") } ?: ""
|
||||
val engine = prefs.getString(gamePrefix + "engine", ENGINE_OFF)
|
||||
.let { if (it == LEGACY_ENGINE_WINFG) ENGINE_DDFG else it ?: ENGINE_OFF }
|
||||
val target = prefs.getInt(gamePrefix + "target", 0)
|
||||
if (engine == ENGINE_LSFG && target in ADAPTIVE_TARGETS) return Mode(engine, target = target)
|
||||
return Mode(engine, prefs.getInt("multiplier", 2).coerceIn(2, 4))
|
||||
return Mode(engine, prefs.getInt(gamePrefix + "multiplier", 2).coerceIn(2, 4))
|
||||
}
|
||||
|
||||
fun hasGameOverride(context: Context, appId: String): Boolean =
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).contains("game.$appId.engine")
|
||||
|
||||
fun setForGame(context: Context, appId: String, mode: Mode) {
|
||||
val prefix = "game.$appId."
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.putString(prefix + "engine", mode.engine)
|
||||
.putInt(prefix + "multiplier", mode.multiplier)
|
||||
.putInt(prefix + "target", mode.target)
|
||||
.apply()
|
||||
}
|
||||
|
||||
fun clearGame(context: Context, appId: String) {
|
||||
val prefix = "game.$appId."
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.remove(prefix + "engine")
|
||||
.remove(prefix + "multiplier")
|
||||
.remove(prefix + "target")
|
||||
.apply()
|
||||
}
|
||||
|
||||
fun set(context: Context, mode: Mode) {
|
||||
@@ -41,6 +67,11 @@ object FrameGen {
|
||||
.putString("engine", mode.engine).putInt("multiplier", mode.multiplier).putInt("target", mode.target).apply()
|
||||
}
|
||||
|
||||
fun clearGlobal(context: Context) {
|
||||
context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit()
|
||||
.remove("engine").remove("multiplier").remove("target").apply()
|
||||
}
|
||||
|
||||
fun label(context: Context): String = label(context, mode(context))
|
||||
|
||||
fun label(context: Context, mode: Mode): String = when {
|
||||
@@ -50,14 +81,32 @@ object FrameGen {
|
||||
else -> context.getString(R.string.frame_gen_off)
|
||||
}
|
||||
|
||||
fun apply(context: Context, refreshHz: Float): String? = apply(context, mode(context), refreshHz)
|
||||
data class PreparedApply internal constructor(
|
||||
val mode: Mode,
|
||||
internal val lsfgStatus: Int? = null,
|
||||
internal val lsfgCachePath: String? = null,
|
||||
)
|
||||
|
||||
fun apply(context: Context, mode: Mode, refreshHz: Float): String? {
|
||||
fun prepareApply(context: Context, mode: Mode): PreparedApply {
|
||||
if (mode.engine != ENGINE_LSFG) return PreparedApply(mode)
|
||||
val status = Lossless.sync(context)
|
||||
val cachePath = Lossless.cacheFile(context)?.absolutePath
|
||||
return PreparedApply(mode, status, cachePath)
|
||||
}
|
||||
|
||||
fun apply(context: Context, refreshHz: Float): String? =
|
||||
apply(context, mode(context), refreshHz)
|
||||
|
||||
fun apply(context: Context, mode: Mode, refreshHz: Float): String? =
|
||||
applyPrepared(context, prepareApply(context, mode), refreshHz)
|
||||
|
||||
fun applyPrepared(context: Context, prepared: PreparedApply, refreshHz: Float): String? {
|
||||
val mode = prepared.mode
|
||||
when (mode.engine) {
|
||||
ENGINE_LSFG -> {
|
||||
val status = Lossless.sync(context)
|
||||
val cache = Lossless.cacheFile(context)
|
||||
if (status != LsfgNative.STATUS_OK || cache == null) {
|
||||
val status = prepared.lsfgStatus ?: LsfgNative.STATUS_NOT_INSTALLED
|
||||
val cachePath = prepared.lsfgCachePath
|
||||
if (status != LsfgNative.STATUS_OK || cachePath == null) {
|
||||
WaylandCompositor.nativeSetFrameGenArmed(false, 0, 0)
|
||||
val problem = context.getString(
|
||||
if (status == LsfgNative.STATUS_NOT_INSTALLED) R.string.lsfg_problem_missing else R.string.lsfg_problem_failed,
|
||||
@@ -66,7 +115,7 @@ object FrameGen {
|
||||
return problem
|
||||
}
|
||||
WaylandCompositor.nativeSetFrameGenEngine(WaylandCompositor.FG_ENGINE_LSFG)
|
||||
WaylandCompositor.nativeSetLsfgCachePath(cache.absolutePath)
|
||||
WaylandCompositor.nativeSetLsfgCachePath(cachePath)
|
||||
WaylandCompositor.nativeSetFrameGenTuning(FLOW_SCALE_LSFG, refreshHz)
|
||||
WaylandCompositor.nativeSetFrameGenArmed(true, mode.multiplier, mode.target)
|
||||
}
|
||||
|
||||
@@ -34,6 +34,8 @@ public final class TurnipDriver {
|
||||
public static final List<String> BUNDLED = Collections.unmodifiableList(Arrays.asList(
|
||||
DRIVER_A7XX, DRIVER_A8XX, com.droiddeck.launcher.session.QuestExperimental.DRIVER,
|
||||
DRIVER_A6XX, com.droiddeck.launcher.session.QuestExperimental.DRIVER_A6XX));
|
||||
private static final String KGSL_NODE = "/dev/kgsl-3d0";
|
||||
private static final String KGSL_SYSFS = "/sys/class/kgsl/kgsl-3d0";
|
||||
private static final String OVERRIDE_FILE = "Download/droiddeck-driver";
|
||||
private static final String PREFS = "graphics_driver";
|
||||
private static final String KEY_HIDDEN = "hiddenBundled";
|
||||
@@ -140,6 +142,25 @@ public final class TurnipDriver {
|
||||
return id == null ? "system" : id;
|
||||
}
|
||||
|
||||
public String effectiveId() {
|
||||
String id = choose();
|
||||
return id == null || !reachesGpu(id) ? "system" : id;
|
||||
}
|
||||
|
||||
public boolean reachesGpu(String driverId) {
|
||||
String library = libraryName(driverId);
|
||||
return library == null || !needsMissingKgsl(new File(new File(contentDir, driverId), library),
|
||||
kgslPresent(new File(KGSL_NODE), new File(KGSL_SYSFS)));
|
||||
}
|
||||
|
||||
static boolean kgslPresent(File node, File sysfs) {
|
||||
return node.exists() || sysfs.exists();
|
||||
}
|
||||
|
||||
static boolean needsMissingKgsl(File library, boolean kgsl) {
|
||||
return !kgsl && library.isFile() && LinuxVulkanDriverManager.containsAscii(library, KGSL_NODE);
|
||||
}
|
||||
|
||||
public void remove(String driverId) {
|
||||
if (driverId == null || driverId.isEmpty() || BUNDLED.contains(driverId)
|
||||
|| driverId.contains("/") || driverId.contains("..")) return;
|
||||
@@ -257,6 +278,11 @@ public final class TurnipDriver {
|
||||
Log.e(TAG, id + " unpacked without " + library);
|
||||
return null;
|
||||
}
|
||||
if (!reachesGpu(id)) {
|
||||
Log.w(TAG, id + " needs " + KGSL_NODE + ", which this GPU does not have; display on the system Vulkan loader");
|
||||
DriverSetupLog.write(context, "install.no-kgsl driver=" + id);
|
||||
return null;
|
||||
}
|
||||
Log.i(TAG, "graphics driver " + id + " (" + library + ")");
|
||||
DriverSetupLog.write(context, "install.ready driver=" + id + " library=" + library);
|
||||
return id;
|
||||
@@ -282,6 +308,12 @@ public final class TurnipDriver {
|
||||
}
|
||||
}
|
||||
if (chosen != null && !chosen.isEmpty()) {
|
||||
if (SessionPrefs.GPU_DRIVERS_AUTO.equals(SessionPrefs.INSTANCE.gpuDriverMode(context))
|
||||
&& SessionPrefs.INSTANCE.gpuAutoInstalled(context).contains(chosen)
|
||||
&& gpuDetector.get().getFamily() == GpuInfo.Family.A7XX_LOW) {
|
||||
Log.i(TAG, "Auto-selected display driver does not cover Adreno 710/720/722; leaving the display driver to the system");
|
||||
return null;
|
||||
}
|
||||
if (BUNDLED.contains(chosen)) {
|
||||
Log.i(TAG, "driver pinned by the user: " + chosen);
|
||||
return chosen;
|
||||
@@ -318,6 +350,10 @@ public final class TurnipDriver {
|
||||
Log.i(TAG, "not an Adreno GPU; leaving the display driver to the system");
|
||||
return null;
|
||||
}
|
||||
if (gpu.getFamily() == GpuInfo.Family.A7XX_LOW) {
|
||||
Log.i(TAG, "no bundled display driver covers Adreno 710/720/722; leaving the display driver to the system");
|
||||
return null;
|
||||
}
|
||||
int model = gpu.getModel();
|
||||
Log.i(TAG, "gpu model: " + (model == 0 ? "unknown" : model));
|
||||
return chooseByModel(model, android.os.Build.VERSION.SDK_INT);
|
||||
|
||||
@@ -7,15 +7,21 @@ internal object DroidDeckHudConfig {
|
||||
val DEFAULTS: Map<String, String> = linkedMapOf(
|
||||
"hudSize" to "minimal", "hudLocked" to "1", "hudSnap" to "1", "hudScale" to "100", "hudDock" to "none", "hudOpacity" to "80", "hudColor" to "mid",
|
||||
"hudOutline" to "40", "hudOutlineAccent" to "1",
|
||||
"showFPS" to "1", "showFPSGraph" to "1", "showCPUUsage" to "1", "showCPULoad" to "1", "showGPULoad" to "1",
|
||||
"showVram" to "1", "showRAM" to "1", "showPower" to "1", "showTemp" to "1", "showBatteryTemp" to "1",
|
||||
"showGpuTemp" to "0", "showBattery" to "0", "showLow1" to "1", "showLow01" to "1", "showLow001" to "1", "fpsDecimal" to "1", "showPerCore" to "1",
|
||||
"showSwap" to "1", "showNet" to "1", "showResolution" to "1", "showProton" to "1", "showSession" to "1",
|
||||
"showClock" to "1", "showEngine" to "1", "showRenderer" to "1", "showGpuModel" to "1",
|
||||
"showGpuModel" to "1", "showGPULoad" to "1", "showCPUUsage" to "1", "showCPULoad" to "1",
|
||||
"showPerCore" to "1", "showTemp" to "1", "showBatteryTemp" to "1", "showGpuTemp" to "0",
|
||||
"showVram" to "1", "showRAM" to "1", "showSwap" to "1", "showBattery" to "0", "showBatteryTime" to "0", "showPower" to "1",
|
||||
"showFPS" to "1", "showFPSGraph" to "1", "fpsDecimal" to "1",
|
||||
"showLatency" to "1", "showAvg" to "1", "showLow1" to "1", "showLow01" to "1", "showLow001" to "1",
|
||||
"showEngine" to "1", "showRenderer" to "1",
|
||||
"showDisplay" to "1", "showHdr" to "1", "showNet" to "1", "showResolution" to "1",
|
||||
"showProton" to "1", "showSession" to "1", "showClock" to "1", "hudOrder" to "",
|
||||
"tempUnit" to "c", "tempBands" to "1", "tempAuto" to "1", "tempRedCpu" to "90", "tempRedGpu" to "90", "tempRedBat" to "48",
|
||||
)
|
||||
|
||||
private val TWINS = mapOf("showCPUUsage" to "showCPULoad", "showTemp" to "showBatteryTemp", "showEngine" to "showRenderer")
|
||||
private val NOT_READINGS = setOf("showCPULoad", "showRenderer", "fpsDecimal")
|
||||
|
||||
/** Orders saved before the GPU switch was named after the alias the HUD actually reads. */
|
||||
private val RENAMED = mapOf("showGPU" to "showGPULoad")
|
||||
|
||||
fun load(context: Context): MutableMap<String, String> {
|
||||
val values = LinkedHashMap(DEFAULTS)
|
||||
@@ -36,7 +42,31 @@ internal object DroidDeckHudConfig {
|
||||
val values = load(context)
|
||||
if (key !in DEFAULTS) return values
|
||||
values[key] = value
|
||||
TWINS[key]?.let { values[it] = value }
|
||||
SessionPrefs.setDroidDeckHudConfig(context, encode(values))
|
||||
return values
|
||||
}
|
||||
|
||||
/** Writes several switches and the row order in one go, so the HUD is rebuilt once. */
|
||||
fun choose(context: Context, switches: Map<String, Boolean>, order: List<String>): Map<String, String> {
|
||||
val values = load(context)
|
||||
for ((key, on) in switches) if (key in DEFAULTS) {
|
||||
values[key] = flag(on)
|
||||
}
|
||||
val size = DroidDeckHudSize.from(values["hudSize"])
|
||||
val groups = sizeOrders(values).toMutableMap()
|
||||
if (groups.isEmpty()) {
|
||||
val legacy = legacyOrder(values)
|
||||
if (legacy.isNotEmpty()) for (each in DroidDeckHudSize.values()) groups[each] = legacy.filter { it in each.rows }
|
||||
}
|
||||
groups[size] = order.filter { it in ORDER }
|
||||
values["hudOrder"] = encodeOrders(groups)
|
||||
SessionPrefs.setDroidDeckHudConfig(context, encode(values))
|
||||
return values
|
||||
}
|
||||
|
||||
fun clearOrder(context: Context): Map<String, String> {
|
||||
val values = load(context)
|
||||
values["hudOrder"] = ""
|
||||
SessionPrefs.setDroidDeckHudConfig(context, encode(values))
|
||||
return values
|
||||
}
|
||||
@@ -46,5 +76,37 @@ internal object DroidDeckHudConfig {
|
||||
return DEFAULTS
|
||||
}
|
||||
|
||||
/** Every metric switch, in the order the HUD lists them before the user moves any. Derived from
|
||||
* [DEFAULTS], so a switch added there shows up here without a second list to keep in step. */
|
||||
val ORDER: List<String> = DEFAULTS.keys.filter { it.startsWith("show") && it !in NOT_READINGS }
|
||||
|
||||
/** Only the rows the user moved for [size], in the order they left them. */
|
||||
fun storedOrder(values: Map<String, String>, size: DroidDeckHudSize): List<String> =
|
||||
sizeOrders(values)[size] ?: legacyOrder(values)
|
||||
|
||||
/** Orders saved before each size kept its own: one list, applied to every size. */
|
||||
private fun legacyOrder(values: Map<String, String>): List<String> {
|
||||
val raw = values["hudOrder"].orEmpty()
|
||||
if (raw.isBlank() || raw.contains(':')) return emptyList()
|
||||
return raw.split('|').map { RENAMED[it] ?: it }.filter { it in ORDER }
|
||||
}
|
||||
|
||||
private fun sizeOrders(values: Map<String, String>): Map<DroidDeckHudSize, List<String>> {
|
||||
val raw = values["hudOrder"].orEmpty()
|
||||
if (raw.isBlank()) return emptyMap()
|
||||
val groups = LinkedHashMap<DroidDeckHudSize, List<String>>()
|
||||
for (group in raw.split(';')) {
|
||||
val colon = group.indexOf(':')
|
||||
if (colon <= 0) continue
|
||||
val size = DroidDeckHudSize.values().firstOrNull { it.token == group.substring(0, colon) } ?: continue
|
||||
groups[size] = group.substring(colon + 1).split('|').map { RENAMED[it] ?: it }.filter { it in ORDER }
|
||||
}
|
||||
return groups
|
||||
}
|
||||
|
||||
private fun encodeOrders(groups: Map<DroidDeckHudSize, List<String>>): String =
|
||||
groups.entries.filter { it.value.isNotEmpty() }
|
||||
.joinToString(";") { "${it.key.token}:${it.value.joinToString("|")}" }
|
||||
|
||||
private fun flag(on: Boolean) = if (on) "1" else "0"
|
||||
}
|
||||
@@ -10,11 +10,9 @@ import android.view.View
|
||||
import android.view.animation.PathInterpolator
|
||||
import android.view.ViewGroup
|
||||
import android.widget.FrameLayout
|
||||
import com.droiddeck.launcher.gpu.FrameGen
|
||||
import com.droiddeck.launcher.gpu.GpuInfo
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
import com.droiddeck.launcher.session.SessionService
|
||||
import com.droiddeck.launcher.session.SessionState
|
||||
import com.droiddeck.launcher.ui.Motion
|
||||
import com.droiddeck.launcher.wayland.WaylandCompositor
|
||||
@@ -24,7 +22,7 @@ import kotlin.math.roundToInt
|
||||
class DroidDeckHudHost(context: Context) {
|
||||
private val context = context.applicationContext
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private val feed = GameFrameFeed(File(LinuxRuntime.rootDir(this.context), HudFrames.PATH))
|
||||
private val feed = GameFrameFeed.forRoot(LinuxRuntime.rootDir(this.context))
|
||||
private val readings = MangoReadings(File(this.context.filesDir, "session"), LinuxRuntime.rootDir(this.context))
|
||||
private var view: DroidDeckHudView? = null
|
||||
private var parent: ViewGroup? = null
|
||||
@@ -39,6 +37,8 @@ class DroidDeckHudHost(context: Context) {
|
||||
private var snapping = false
|
||||
private var previewFade: ValueAnimator? = null
|
||||
private var flingX = 0f
|
||||
private var flingY = 0f
|
||||
private var throwSpring: com.droiddeck.launcher.ui.FlingSpring? = null
|
||||
private var engine = ""
|
||||
private var gpuName = ""
|
||||
private var protonPid = 0
|
||||
@@ -95,18 +95,22 @@ class DroidDeckHudHost(context: Context) {
|
||||
stopMotion(hud)
|
||||
shrinkPastEdge(hud, rawX, rawY)
|
||||
}
|
||||
hud.setOnFlungListener { vx, _ -> flingX = vx }
|
||||
hud.setOnFlungListener { vx, vy -> flingX = vx; flingY = vy }
|
||||
hud.setOnTabDraggedListener { x, y -> dragTab(hud, x, y) }
|
||||
hud.setOnTabDroppedListener { dropTab(hud) }
|
||||
hud.setOnTabDragCancelledListener { snapping = false; keepOnScreen(hud) }
|
||||
hud.setOnMovedListener { x, y ->
|
||||
wantX = x; wantY = y
|
||||
val vx = flingX
|
||||
val vy = flingY
|
||||
flingX = 0f
|
||||
dockEdgeFor(hud)?.let { edge -> setDock(hud, edge); return@setOnMovedListener }
|
||||
flingY = 0f
|
||||
// A throw only carries the strip into its tab; a floating HUD flung across goes to the other side.
|
||||
val coast = hud.isStrip
|
||||
dockEdgeFor(hud, if (coast) vx else 0f, if (coast) vy else 0f)?.let { edge -> setDock(hud, edge); return@setOnMovedListener }
|
||||
stopMotion(hud)
|
||||
fadeDockPreview(hud)
|
||||
if (snaps && !hud.isStrip) { snapToAnchor(hud, vx); return@setOnMovedListener }
|
||||
if (snaps && !hud.isStrip) { snapToAnchor(hud, vx, vy); return@setOnMovedListener }
|
||||
val fromX = hud.x; val fromY = hud.y
|
||||
keepOnScreen(hud)
|
||||
wantX = hud.x; wantY = hud.y
|
||||
@@ -179,9 +183,8 @@ class DroidDeckHudHost(context: Context) {
|
||||
private fun applyShown() {
|
||||
if (!running) return
|
||||
val show = !hidden && !backgrounded
|
||||
val visible = show && SessionState.mode != SessionService.MODE_DESKTOP
|
||||
view?.visibility = if (visible) View.VISIBLE else View.GONE
|
||||
showing = visible
|
||||
view?.visibility = if (show) View.VISIBLE else View.GONE
|
||||
showing = show
|
||||
if (show != polling) {
|
||||
polling = show
|
||||
if (show) Choreographer.getInstance().postFrameCallback(frameCallback)
|
||||
@@ -238,28 +241,36 @@ class DroidDeckHudHost(context: Context) {
|
||||
}
|
||||
|
||||
private fun presentedFps(): Float {
|
||||
if (FrameGen.mode(context).engine == FrameGen.ENGINE_OFF) return 0f
|
||||
val stats = runCatching { WaylandCompositor.nativeFrameGenStats() }.getOrNull() ?: return 0f
|
||||
if (!runCatching { WaylandCompositor.nativeFrameGenActive() }
|
||||
.getOrDefault(false)) return 0f
|
||||
|
||||
val stats = runCatching {
|
||||
WaylandCompositor.nativeFrameGenStats()
|
||||
}.getOrNull() ?: return 0f
|
||||
|
||||
return if (stats.size > 3 && stats[3] > 1f) stats[3] else 0f
|
||||
}
|
||||
|
||||
private fun dockEdgeFor(v: View): DroidDeckHudDock? {
|
||||
val over = overhang(v) ?: return null
|
||||
/** The edge the HUD tucks into: one it hangs far enough over, or would once a throw at [vx], [vy] coasts out. */
|
||||
private fun dockEdgeFor(v: View, vx: Float = 0f, vy: Float = 0f): DroidDeckHudDock? {
|
||||
val over = overhang(v, vx * com.droiddeck.launcher.ui.EdgeFling.COAST_S, vy * com.droiddeck.launcher.ui.EdgeFling.COAST_S) ?: return null
|
||||
return over.key.takeIf { over.value >= DOCK_OVERHANG }
|
||||
}
|
||||
|
||||
private fun overhang(v: View): Map.Entry<DroidDeckHudDock, Float>? {
|
||||
private fun overhang(v: View, dx: Float = 0f, dy: Float = 0f): Map.Entry<DroidDeckHudDock, Float>? {
|
||||
val p = v.parent as? View ?: return null
|
||||
if (p.width <= 0 || p.height <= 0 || v.width <= 0 || v.height <= 0) return null
|
||||
val strip = (v as? DroidDeckHudView)?.isStrip == true
|
||||
val density = v.resources.displayMetrics.density
|
||||
val w = if (strip) minOf(v.width.toFloat(), STRIP_PULL_ACROSS_DP * density) else v.width.toFloat()
|
||||
val h = if (strip) maxOf(v.height.toFloat(), STRIP_PULL_OFF_DP * density) else v.height.toFloat()
|
||||
val x = v.x + dx
|
||||
val y = v.y + dy
|
||||
return mapOf(
|
||||
DroidDeckHudDock.LEFT to -v.x / w,
|
||||
DroidDeckHudDock.RIGHT to (v.x + v.width - p.width) / w,
|
||||
DroidDeckHudDock.TOP to -v.y / h,
|
||||
DroidDeckHudDock.BOTTOM to (v.y + v.height - p.height) / h,
|
||||
DroidDeckHudDock.LEFT to -x / w,
|
||||
DroidDeckHudDock.RIGHT to (x + v.width - p.width) / w,
|
||||
DroidDeckHudDock.TOP to -y / h,
|
||||
DroidDeckHudDock.BOTTOM to (y + v.height - p.height) / h,
|
||||
).maxByOrNull { it.value }
|
||||
}
|
||||
|
||||
@@ -294,6 +305,7 @@ class DroidDeckHudHost(context: Context) {
|
||||
}
|
||||
|
||||
private fun stopMotion(hud: DroidDeckHudView) {
|
||||
throwSpring?.cancel()
|
||||
hud.animate().setUpdateListener(null)
|
||||
hud.animate().cancel()
|
||||
}
|
||||
@@ -323,23 +335,21 @@ class DroidDeckHudHost(context: Context) {
|
||||
}
|
||||
}
|
||||
|
||||
private fun snapToAnchor(hud: DroidDeckHudView, vx: Float) {
|
||||
/** Sends the HUD to a side the way a chat head goes: by where the throw would carry it, springing on from its speed. */
|
||||
private fun snapToAnchor(hud: DroidDeckHudView, vx: Float, vy: Float) {
|
||||
val p = hud.parent as? View ?: return
|
||||
val maxX = (p.width - hud.width).toFloat().coerceAtLeast(0f)
|
||||
val maxY = (p.height - hud.height).toFloat().coerceAtLeast(0f)
|
||||
anchorX = if (hud.x + vx * FLING_REACH_S < maxX / 2f) 0f else 1f
|
||||
val right = com.droiddeck.launcher.ui.EdgeFling.toRight(hud.x + hud.width / 2f, p.width.toFloat(), vx, context.resources.displayMetrics.density)
|
||||
anchorX = if (right) 1f else 0f
|
||||
wantX = anchorX * maxX
|
||||
wantY = hud.y.coerceIn(0f, maxY)
|
||||
wantY = com.droiddeck.launcher.ui.EdgeFling.restY(hud.y, vy, 0f, maxY)
|
||||
SessionPrefs.setDroidDeckHudPosition(context, wantX, wantY)
|
||||
stopMotion(hud)
|
||||
if (Motion.scale == 0f) {
|
||||
hud.scaleX = 1f; hud.scaleY = 1f
|
||||
hud.x = wantX; hud.y = wantY
|
||||
return
|
||||
}
|
||||
hud.scaleX = 1f; hud.scaleY = 1f
|
||||
snapping = true
|
||||
hud.animate().x(wantX).y(wantY).scaleX(1f).scaleY(1f).setDuration(Motion.ms(260).toLong()).setInterpolator(EASE)
|
||||
.withEndAction { snapping = false; keepOnScreen(hud) }.start()
|
||||
val spring = throwSpring ?: com.droiddeck.launcher.ui.FlingSpring { sx, sy -> hud.x = sx; hud.y = sy }.also { throwSpring = it }
|
||||
spring.start(hud.x, hud.y, vx, vy, wantX, wantY) { snapping = false; keepOnScreen(hud) }
|
||||
}
|
||||
|
||||
private fun shrinkPastEdge(hud: DroidDeckHudView, rawX: Float, rawY: Float) {
|
||||
@@ -496,10 +506,9 @@ class DroidDeckHudHost(context: Context) {
|
||||
|
||||
companion object {
|
||||
private const val DOCK_OVERHANG = 0.4f
|
||||
private const val FLING_REACH_S = 0.18f
|
||||
private const val PREVIEW_FROM = 0.55f
|
||||
private const val STRIP_PULL_ACROSS_DP = 600f
|
||||
private const val STRIP_PULL_OFF_DP = 150f
|
||||
private const val STRIP_PULL_ACROSS_DP = 360f
|
||||
private const val STRIP_PULL_OFF_DP = 100f
|
||||
private const val EXPAND_FADE = 0.5f
|
||||
private val EASE = PathInterpolator(0.2f, 0.8f, 0.2f, 1f)
|
||||
|
||||
|
||||
@@ -13,6 +13,27 @@
|
||||
|
||||
package com.droiddeck.launcher.hud
|
||||
|
||||
/**
|
||||
* Size modes for the DroidDeck HUD (the 4th selectable in-game overlay style). One shared color-coded
|
||||
* visual language, four amounts of detail — see the approved mockup. The config value is the lower-case
|
||||
* token stored under the `hudSize` key; the label is the user-facing string.
|
||||
*/
|
||||
/** The text sizes and spacing a [DroidDeckHudSize] lays its rows out with, in sp. */
|
||||
data class DroidDeckHudStyle(
|
||||
val row: Float,
|
||||
val unit: Float,
|
||||
val pad: Float,
|
||||
val lineGap: Float,
|
||||
val labelGap: Float,
|
||||
val key: Float = 0f,
|
||||
val sub: Float = 0f,
|
||||
val foot: Float = 0f,
|
||||
val band: Float = 0f,
|
||||
val gutter: Float = 0f,
|
||||
val tileGap: Float = 0f,
|
||||
val innerPad: Float = 0f,
|
||||
)
|
||||
|
||||
enum class DroidDeckHudSize(val token: String, val label: String) {
|
||||
FULL("full", "Full"),
|
||||
TILES("tiles", "Tiles"),
|
||||
@@ -26,27 +47,73 @@ enum class DroidDeckHudSize(val token: String, val label: String) {
|
||||
return all[(ordinal + 1) % all.size]
|
||||
}
|
||||
|
||||
fun supportedChips(): Set<String> = when (this) {
|
||||
MINIMAL -> MINIMAL_CHIPS
|
||||
PILL -> PILL_CHIPS
|
||||
FULL, TILES, STRIP -> STANDARD_CHIPS
|
||||
MEGA -> MEGA_CHIPS
|
||||
}
|
||||
/**
|
||||
* The rows this size draws, in the order it draws them before the user moves any. This is the single
|
||||
* source of truth for both surfaces: [DroidDeckHudView] draws exactly these and the settings screen
|
||||
* offers exactly these. A switch outside the set is ignored by the size, so the two cannot drift.
|
||||
*/
|
||||
val rows: List<String> get() = ROWS.getValue(this)
|
||||
|
||||
/** This size's rows: the ones the user moved first, then the rest in the order [rows] lists them. */
|
||||
fun rowsIn(stored: List<String>): List<String> =
|
||||
stored.filter { it in rows } + rows.filter { it !in stored }
|
||||
/**
|
||||
* The numbers each size sets its text in, in sp. One table so a size's scale can be read (and changed)
|
||||
* in one place instead of hunting the `sp(...)` literals scattered through its builder.
|
||||
*/
|
||||
val style: DroidDeckHudStyle get() = STYLE.getValue(this)
|
||||
|
||||
|
||||
companion object {
|
||||
fun from(token: String?): DroidDeckHudSize =
|
||||
values().firstOrNull { it.token.equals(token, ignoreCase = true) } ?: FULL
|
||||
|
||||
val MINIMAL_CHIPS = setOf("FPS", "FPS graph", "1% low", "0.1% low", "0.01% low", "FPS .1", "Engine", "Clock")
|
||||
val PILL_CHIPS = setOf("FPS", "FPS graph", "GPU", "CPU", "VRAM", "RAM", "Battery", "GPU model", "FPS .1", "Engine", "Clock")
|
||||
val STANDARD_CHIPS = setOf(
|
||||
"FPS", "FPS graph", "GPU", "GPU temp", "CPU", "VRAM", "RAM", "Power", "Temp",
|
||||
"Battery", "GPU model", "Engine", "1% low", "0.1% low", "0.01% low", "FPS .1", "Clock",
|
||||
private val EXTRAS = setOf("showClock")
|
||||
|
||||
val ROWS: Map<DroidDeckHudSize, List<String>> = mapOf(
|
||||
FULL to listOf(
|
||||
"showFPS", "showFPSGraph", "showGpuModel", "showDisplay", "showHdr", "showGPULoad", "showGpuTemp",
|
||||
"showCPUUsage", "showTemp", "showVram", "showRAM", "showBattery", "showBatteryTemp", "showBatteryTime",
|
||||
"showPower", "showLatency", "showAvg", "showLow1", "showLow01", "showLow001",
|
||||
),
|
||||
TILES to listOf(
|
||||
"showFPS", "showFPSGraph", "showLatency", "showGPULoad", "showGpuTemp", "showCPUUsage", "showTemp",
|
||||
"showVram", "showRAM", "showEngine", "showDisplay", "showHdr", "showAvg", "showLow1",
|
||||
"showLow01", "showLow001", "showGpuModel", "showBattery", "showBatteryTemp", "showBatteryTime", "showPower",
|
||||
),
|
||||
PILL to listOf(
|
||||
"showFPS", "showFPSGraph", "showGpuModel", "showGPULoad", "showGpuTemp", "showCPUUsage", "showTemp",
|
||||
"showRAM", "showBattery", "showBatteryTemp", "showBatteryTime", "showPower", "showLatency", "showDisplay",
|
||||
"showVram", "showHdr",
|
||||
),
|
||||
MINIMAL to listOf(
|
||||
"showFPS", "showBatteryTime", "showFPSGraph", "showLow1", "showLow01", "showLow001", "showAvg", "showLatency",
|
||||
"showEngine", "showDisplay", "showHdr",
|
||||
),
|
||||
MEGA to DroidDeckHudConfig.ORDER.filter { it !in EXTRAS },
|
||||
STRIP to listOf(
|
||||
"showFPS", "showFPSGraph", "showLow1", "showLow01", "showLow001", "showGPULoad", "showGpuTemp",
|
||||
"showCPUUsage", "showTemp", "showVram", "showRAM", "showBattery", "showBatteryTemp", "showBatteryTime",
|
||||
"showPower", "showDisplay", "showHdr", "showGpuModel",
|
||||
),
|
||||
)
|
||||
val MEGA_ONLY = setOf(
|
||||
"Per-core", "Swap", "Network", "Resolution", "Proton", "Wrapper", "DX ver", "Session",
|
||||
|
||||
|
||||
val STYLE: Map<DroidDeckHudSize, DroidDeckHudStyle> = mapOf(
|
||||
FULL to DroidDeckHudStyle(row = 12f, unit = 12f * 0.62f, pad = 10f, lineGap = 4f, labelGap = 8f),
|
||||
TILES to DroidDeckHudStyle(row = 18f, unit = 11f, pad = 9f, lineGap = 4f, labelGap = 8f,
|
||||
key = 10f, sub = 10f, tileGap = 6f, innerPad = 8f),
|
||||
PILL to DroidDeckHudStyle(row = 30f, unit = 30f * 0.36f, pad = 10f, lineGap = 3f, labelGap = 12f,
|
||||
sub = 11.5f),
|
||||
MINIMAL to DroidDeckHudStyle(row = 34f, unit = 34f * 0.32f, pad = 10f, lineGap = 4f, labelGap = 8f,
|
||||
sub = 11.5f, foot = 9.5f),
|
||||
MEGA to DroidDeckHudStyle(row = 11.5f, unit = 11.5f * 0.62f, pad = 10f, lineGap = 3.5f, labelGap = 7f,
|
||||
band = 9.5f, gutter = 16f),
|
||||
STRIP to DroidDeckHudStyle(row = 11.5f, unit = 11.5f * 0.8f, pad = 10f, lineGap = 0f, labelGap = 13f),
|
||||
)
|
||||
val MEGA_CHIPS = STANDARD_CHIPS + MEGA_ONLY
|
||||
|
||||
fun rowsFor(size: DroidDeckHudSize, values: Map<String, String>): List<String> =
|
||||
size.rowsIn(DroidDeckHudConfig.storedOrder(values, size))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -69,6 +69,7 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
|
||||
private val density = resources.displayMetrics.density
|
||||
|
||||
private var cfg: KeyValueSet = KeyValueSet()
|
||||
private var size = DroidDeckHudSize.FULL
|
||||
private var scale = 1f
|
||||
private var bgOpacity = 0.8f
|
||||
@@ -95,13 +96,16 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
private var showLow001 = true
|
||||
private var fpsDecimal = true
|
||||
private var showClockTime = true
|
||||
private var showLatency = true
|
||||
private var showAvg = true
|
||||
private var showDisplay = true
|
||||
private var showHdr = true
|
||||
private var storedOrder: List<String> = emptyList()
|
||||
private var showPerCore = true
|
||||
private var showSwap = true
|
||||
private var showNet = true
|
||||
private var showResolution = true
|
||||
private var showProton = true
|
||||
private var showWrapper = true
|
||||
private var showDxVer = true
|
||||
private var showSession = true
|
||||
|
||||
private var engineLabel = ""
|
||||
@@ -177,7 +181,7 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
fun moved(dx: Float, dy: Float) = Glyph(x + dx, baseline + dy, text, color, sizePx, glow)
|
||||
}
|
||||
private class Span(val text: String, val color: Int, val sizePx: Float, val glow: Boolean = false)
|
||||
private class HudRow(val label: Span, val vals: List<Span>, val inline: Boolean = false)
|
||||
private class HudRow(val key: String, val label: Span, val vals: List<Span>, val inline: Boolean = false)
|
||||
private val glyphs = ArrayList<Glyph>()
|
||||
private val tileRects = ArrayList<RectF>()
|
||||
private var graphRect: RectF? = null
|
||||
@@ -289,41 +293,52 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
|
||||
private fun cycleSize() {
|
||||
size = size.next()
|
||||
refreshOrder()
|
||||
onSizeCycledListener?.accept(size.token)
|
||||
rebuildAndInvalidate()
|
||||
}
|
||||
|
||||
private fun refreshOrder() {
|
||||
storedOrder = DroidDeckHudConfig.storedOrder(mapOf("hudOrder" to cfg.get("hudOrder", "")), size)
|
||||
}
|
||||
|
||||
private fun switchOn(key: String): Boolean =
|
||||
cfg.get(key, DroidDeckHudConfig.DEFAULTS[key] ?: "1") == "1"
|
||||
|
||||
fun applyConfig(configString: String?) {
|
||||
if (configString.isNullOrEmpty()) return
|
||||
val cfg = KeyValueSet(configString)
|
||||
cfg = KeyValueSet(configString)
|
||||
|
||||
size = DroidDeckHudSize.from(cfg.get("hudSize", "minimal"))
|
||||
showFPS = cfg.get("showFPS", "1") == "1"
|
||||
showEngine = cfg.get("showEngine", "1") == "1"
|
||||
showGpuModel = cfg.get("showGpuModel", "1") == "1"
|
||||
showCPU = cfg.get("showCPUUsage", cfg.get("showCPULoad", "1")) == "1"
|
||||
showGPU = cfg.get("showGPULoad", "1") == "1"
|
||||
showCpuTemp = cfg.get("showTemp", "1") == "1"
|
||||
showGpuTemp = cfg.get("showGpuTemp", "0") == "1"
|
||||
showVram = cfg.get("showVram", "1") == "1"
|
||||
showRAM = cfg.get("showRAM", "1") == "1"
|
||||
showBattery = cfg.get("showBattery", "1") == "1"
|
||||
showPower = cfg.get("showPower", "1") == "1"
|
||||
showBatteryTemp = cfg.get("showBatteryTemp", "0") == "1"
|
||||
showGraph = cfg.get("showFPSGraph", "0") == "1"
|
||||
showLow1 = cfg.get("showLow1", "1") == "1"
|
||||
showLow01 = cfg.get("showLow01", "1") == "1"
|
||||
showLow001 = cfg.get("showLow001", "1") == "1"
|
||||
showFPS = switchOn("showFPS")
|
||||
showEngine = switchOn("showEngine")
|
||||
showGpuModel = switchOn("showGpuModel")
|
||||
showCPU = switchOn("showCPUUsage")
|
||||
showGPU = switchOn("showGPULoad")
|
||||
showCpuTemp = switchOn("showTemp")
|
||||
showGpuTemp = switchOn("showGpuTemp")
|
||||
showVram = switchOn("showVram")
|
||||
showRAM = switchOn("showRAM")
|
||||
showBattery = switchOn("showBattery")
|
||||
showPower = switchOn("showPower")
|
||||
showBatteryTemp = switchOn("showBatteryTemp")
|
||||
showGraph = switchOn("showFPSGraph")
|
||||
showLow001 = switchOn("showLow001")
|
||||
fpsDecimal = cfg.get("fpsDecimal", "1") == "1"
|
||||
showClockTime = cfg.get("showClock", "1") == "1"
|
||||
showPerCore = cfg.get("showPerCore", "1") == "1"
|
||||
showSwap = cfg.get("showSwap", "1") == "1"
|
||||
showNet = cfg.get("showNet", "1") == "1"
|
||||
showResolution = cfg.get("showResolution", "1") == "1"
|
||||
showProton = cfg.get("showProton", "1") == "1"
|
||||
showWrapper = cfg.get("showWrapper", "1") == "1"
|
||||
showDxVer = cfg.get("showDxVer", "1") == "1"
|
||||
showSession = cfg.get("showSession", "1") == "1"
|
||||
showClockTime = switchOn("showClock")
|
||||
showLatency = switchOn("showLatency")
|
||||
showAvg = switchOn("showAvg")
|
||||
showLow1 = switchOn("showLow1")
|
||||
showLow01 = switchOn("showLow01")
|
||||
showDisplay = switchOn("showDisplay")
|
||||
showHdr = switchOn("showHdr")
|
||||
refreshOrder()
|
||||
showPerCore = switchOn("showPerCore")
|
||||
showSwap = switchOn("showSwap")
|
||||
showNet = switchOn("showNet")
|
||||
showResolution = switchOn("showResolution")
|
||||
showProton = switchOn("showProton")
|
||||
showSession = switchOn("showSession")
|
||||
tempDisplay = HudMetrics.TempDisplay.from(cfg)
|
||||
lockController.setLocked(cfg.get("hudLocked", "1") == "1")
|
||||
dock = DroidDeckHudDock.from(cfg.get("hudDock", "none"))
|
||||
@@ -458,6 +473,8 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
return w
|
||||
}
|
||||
|
||||
private fun showHdrLine(): Boolean = showHdr && hdrState != DroidDeckHudHdr.NONE
|
||||
|
||||
private fun placeRun(startX: Float, baseline: Float, spans: List<Span>, glow: Boolean = false): Float {
|
||||
var x = startX
|
||||
for (s in spans) {
|
||||
@@ -539,13 +556,15 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
val s = snap
|
||||
if (s == null) { contentW = 0f; contentH = 0f; return }
|
||||
if (dock != DroidDeckHudDock.NONE) { buildDockTab(); return }
|
||||
if (size == DroidDeckHudSize.STRIP) { buildStrip(s); return }
|
||||
buildRows(s)
|
||||
if (contentW <= 0f || contentH <= 0f) return
|
||||
if (size == DroidDeckHudSize.PILL) addSubtleClock(sp(10f), leftAligned = true)
|
||||
val pad = sp(size.style.pad)
|
||||
when (size) {
|
||||
DroidDeckHudSize.FULL -> { buildFull(s); intoPanel(sp(10f), header = true) }
|
||||
DroidDeckHudSize.TILES -> { buildTiles(s); intoPanel(sp(9f), header = true) }
|
||||
DroidDeckHudSize.PILL -> { buildPill(s); intoPanel(sp(10f), header = false) }
|
||||
DroidDeckHudSize.MINIMAL -> buildMinimal(s)
|
||||
DroidDeckHudSize.MEGA -> { buildMega(s); intoPanel(sp(10f), header = true) }
|
||||
DroidDeckHudSize.STRIP -> buildStrip(s)
|
||||
DroidDeckHudSize.MINIMAL -> intoPanel(pad, header = true, halfRound = true)
|
||||
DroidDeckHudSize.PILL -> intoPanel(pad, header = false)
|
||||
else -> intoPanel(pad, header = true)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -615,7 +634,12 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
return Pair(dDividerTop + max(1f, density), x)
|
||||
}
|
||||
|
||||
private fun intoPanel(pad: Float, header: Boolean) {
|
||||
/**
|
||||
* Moves a size's content, laid out from [pad] at the origin, into the panel: under the header, or after
|
||||
* the logo chip on the Pill. Lines that start on the content's left edge are lined up by their ink, so
|
||||
* the logo, labels and numbers share one edge.
|
||||
*/
|
||||
private fun intoPanel(pad: Float, header: Boolean, halfRound: Boolean = !header) {
|
||||
if (contentW <= 0f || contentH <= 0f) return
|
||||
for (i in glyphs.indices) {
|
||||
val g = glyphs[i]
|
||||
@@ -641,7 +665,7 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
val panel = RectF(panelLeft(), panelInset(), max(contentW - pad + dx, headerRight) + sp(18f),
|
||||
contentH - pad + dy + sp(10f) + stroke)
|
||||
chipRect?.let { it.offsetTo(it.left, panel.centerY() - it.height() / 2f) }
|
||||
finishPanel(panel, halfRound = !header)
|
||||
finishPanel(panel, halfRound = halfRound)
|
||||
}
|
||||
|
||||
private fun finishPanel(panel: RectF, halfRound: Boolean) {
|
||||
@@ -712,316 +736,188 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
contentW = max(contentW, pad + w + pad)
|
||||
}
|
||||
|
||||
private fun hasGpuStats(s: HudMetrics.Snapshot): Boolean =
|
||||
s.gpuPercent != null || s.gpuTempC != null || s.gpuClockMhz != null
|
||||
|
||||
private fun buildFull(s: HudMetrics.Snapshot) {
|
||||
val rowPx = sp(12f); val unitPx = rowPx * 0.62f
|
||||
val pad = sp(10f); val lineGap = sp(4f); val lvGap = sp(8f)
|
||||
val rows = ArrayList<HudRow>()
|
||||
|
||||
if (showGpuModel && gpuNameText().isNotBlank())
|
||||
rows.add(HudRow(Span("GPU", colGpu, rowPx), gpuModelSpans(rowPx, colValue)))
|
||||
if (displayServer.isNotBlank())
|
||||
rows.add(HudRow(Span("DISP", colDisp, rowPx), listOf(Span(displayServer, colValue, rowPx))))
|
||||
if (hdrState != DroidDeckHudHdr.NONE)
|
||||
rows.add(HudRow(Span("HDR", colHdr, rowPx), hdrValue(rowPx)))
|
||||
if (showGPU && hasGpuStats(s)) {
|
||||
val v = ArrayList<Span>()
|
||||
v += numUnit(s.gpuPercent?.toString(), "%", rowPx, unitPx)
|
||||
if (showGpuTemp) tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, rowPx, unitPx)
|
||||
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
|
||||
v += gap(unitPx); v += numUnit(s.gpuClockMhz?.toString(), "MHz", rowPx, unitPx)
|
||||
rows.add(HudRow(Span("GPU", colGpu, rowPx), v))
|
||||
}
|
||||
if (showCPU) {
|
||||
val v = ArrayList<Span>()
|
||||
v += numUnit(s.cpuPercent?.toString(), "%", rowPx, unitPx)
|
||||
v += gap(unitPx); v += numUnit(s.cpuClockMhz?.toString(), "MHz", rowPx, unitPx)
|
||||
if (showCpuTemp) tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, rowPx, unitPx)
|
||||
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
|
||||
rows.add(HudRow(Span("CPU", colCpu, rowPx), v))
|
||||
}
|
||||
if (showVram && s.vramText() != null)
|
||||
rows.add(HudRow(Span("VRAM", colVram, rowPx), valueUnit(s.vramText()!!, rowPx, unitPx)))
|
||||
if (showRAM) {
|
||||
val v = ArrayList<Span>()
|
||||
v += valueUnit(s.ramUsedText(), rowPx, unitPx)
|
||||
v += gap(unitPx); v += numUnit(s.ramPercent.roundToInt().toString(), "%", rowPx, unitPx)
|
||||
rows.add(HudRow(Span("RAM", colRam, rowPx), v))
|
||||
}
|
||||
if (showBattery || showPower || showBatteryTemp) {
|
||||
val v = ArrayList<Span>(); var any = false
|
||||
if (showBattery && s.battery.percent != null) { v += numUnit(s.battery.percent.toString(), "%", rowPx, unitPx); any = true }
|
||||
if (showBatteryTemp) tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, rowPx, unitPx)
|
||||
.let { if (it.isNotEmpty()) { if (any) v += gap(unitPx); v += it; any = true } }
|
||||
if (showPower && s.battery.watts > 0f) { if (any) v += gap(unitPx); v += numUnit(fmt1(s.battery.watts), "W", rowPx, unitPx); any = true }
|
||||
if (any) rows.add(HudRow(Span("BAT", colBat, rowPx), v))
|
||||
}
|
||||
if (showFPS) {
|
||||
val v = ArrayList<Span>()
|
||||
v += glowing(numUnit(fpsText(fpsNow), "FPS", rowPx, unitPx))
|
||||
v += gap(unitPx); v += numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", rowPx, unitPx)
|
||||
rows.add(HudRow(Span(apiLabel(), colFps, rowPx), v))
|
||||
rows.add(HudRow(Span("AVG", colLo, rowPx), numUnit(fmt1(fpsAvg), "FPS", rowPx, unitPx)))
|
||||
if (showLow1)
|
||||
rows.add(HudRow(Span("1%", colLo, rowPx), numUnit(lowText(lows.low1Fps), "FPS", rowPx, unitPx)))
|
||||
if (showLow01)
|
||||
rows.add(HudRow(Span("0.1%", colLo, rowPx), numUnit(lowText(lows.low01Fps), "FPS", rowPx, unitPx)))
|
||||
if (showLow001)
|
||||
rows.add(HudRow(Span("0.01%", colLo, rowPx), numUnit(lowText(lows.low001Fps), "FPS", rowPx, unitPx)))
|
||||
}
|
||||
|
||||
var labelCol = 0f
|
||||
for (r in rows) if (!r.inline) labelCol = max(labelCol, measure(r.label.text, rowPx))
|
||||
val h = lineH(rowPx); val asc = ascent(rowPx)
|
||||
var y = pad; var maxRight = pad
|
||||
for (r in rows) {
|
||||
val baseline = y - asc
|
||||
placeRun(pad, baseline, listOf(r.label))
|
||||
val valX = if (r.inline) pad + measure(r.label.text, rowPx) + lvGap
|
||||
else pad + labelCol + lvGap
|
||||
val end = placeRun(valX, baseline, r.vals)
|
||||
maxRight = max(maxRight, end)
|
||||
y += h + lineGap
|
||||
}
|
||||
|
||||
if (showFPS && showGraph) {
|
||||
val ftPx = unitPx * 1.15f
|
||||
val baseline = y - asc
|
||||
placeRun(pad, baseline, listOf(Span("Frametime", colFps, ftPx)))
|
||||
val stat = "min:${fmt1(graphMinMs)} max:${fmt1(graphMaxMs)}"
|
||||
val statX = pad + max(labelCol, measure("Frametime", ftPx)) + lvGap
|
||||
val end = placeRun(statX, baseline, listOf(Span(stat, colDim, unitPx)))
|
||||
maxRight = max(maxRight, end)
|
||||
y += h + lineGap
|
||||
val gh = sp(22f)
|
||||
val right = max(maxRight, pad + sp(160f))
|
||||
graphRect = RectF(pad, y, right, y + gh)
|
||||
maxRight = max(maxRight, right)
|
||||
y += gh
|
||||
}
|
||||
|
||||
contentW = maxRight + pad
|
||||
contentH = y + pad
|
||||
addSubtleClock(pad)
|
||||
private fun switchLabel(key: String): Pair<String, Int> = when (key) {
|
||||
"showGpuModel" -> "MODEL" to colGpu
|
||||
"showGPULoad" -> "GPU" to colGpu
|
||||
"showGpuTemp" -> "GPU.T" to colGpu
|
||||
"showCPUUsage" -> "CPU" to colCpu
|
||||
"showTemp" -> "CPU.T" to colCpu
|
||||
"showBatteryTemp" -> "BAT.T" to colBat
|
||||
"showPower" -> "PWR" to colBat
|
||||
"showBattery" -> "BAT" to colBat
|
||||
"showBatteryTime" -> "BAT TIME" to colBat
|
||||
"showVram" -> "VRAM" to colVram
|
||||
"showRAM" -> "RAM" to colRam
|
||||
"showSwap" -> "SWP" to colRam
|
||||
"showNet" -> "NET" to colFps
|
||||
"showPerCore" -> "CORE" to colCpu
|
||||
"showFPS" -> "FPS" to colFps
|
||||
"showLatency" -> "MS" to colDim
|
||||
"showAvg" -> "AVG" to colLo
|
||||
"showLow1" -> "1%" to colLo
|
||||
"showLow01" -> "0.1%" to colLo
|
||||
"showLow001" -> "0.01%" to colLo
|
||||
"showEngine" -> "API" to colFps
|
||||
"showDisplay" -> "DISP" to colDisp
|
||||
"showHdr" -> "HDR" to colHdr
|
||||
"showResolution" -> "RES" to colDim
|
||||
"showProton" -> "PROTON" to colVram
|
||||
"showSession" -> "TIME" to colDim
|
||||
else -> key.removePrefix("show") to colDim
|
||||
}
|
||||
|
||||
private fun buildTiles(s: HudMetrics.Snapshot) {
|
||||
val keyPx = sp(10f); val valPx = sp(18f); val subPx = sp(10f); val unitPx = sp(11f)
|
||||
val pad = sp(9f); val innerPad = sp(8f); val tileGap = sp(6f); val lineGap = sp(4f)
|
||||
|
||||
class Tile(val key: String, val keyColor: Int, val value: List<Span>, val sub: String?, val wide: Boolean)
|
||||
val tiles = ArrayList<Tile>()
|
||||
|
||||
if (showFPS) tiles.add(Tile("FPS", colFps, listOf(Span(fpsText(fpsNow), colValue, valPx, glow = true)),
|
||||
"${fmt1(fpsAvg)} avg" + (if (showLow1) " · ${lowText(lows.low1Fps) ?: "—"} 1%" else ""), false))
|
||||
if (showFPS) tiles.add(Tile("FRAME", colDim, numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", valPx, unitPx),
|
||||
"${fmt1(graphMinMs)} – ${fmt1(graphMaxMs)}", false))
|
||||
if (showGPU && hasGpuStats(s)) tiles.add(Tile("GPU", colGpu, numUnit(s.gpuPercent?.toString(), "%", valPx, unitPx),
|
||||
if (showGpuTemp && s.gpuTempC != null) HudMetrics.formatTemp(s.gpuTempC.toFloat(), tempDisplay, false)
|
||||
else s.gpuClockMhz?.let { "${it}MHz" }, false))
|
||||
if (showCPU) tiles.add(Tile("CPU", colCpu, numUnit(s.cpuPercent?.toString(), "%", valPx, unitPx),
|
||||
listOfNotNull(s.cpuClockMhz?.let { "${it}MHz" },
|
||||
if (showCpuTemp) s.cpuTempC?.let { HudMetrics.formatTemp(it.toFloat(), tempDisplay, false) } else null)
|
||||
.joinToString(" · ").ifBlank { null }, false))
|
||||
if (showVram && s.vramText() != null) tiles.add(Tile("VRAM", colVram, valueUnit(s.vramText()!!, valPx, unitPx), null, false))
|
||||
if (showRAM) tiles.add(Tile("RAM", colRam, numUnit(s.ramPercent.roundToInt().toString(), "%", valPx, unitPx),
|
||||
"${s.ramUsedText()} / ${s.ramTotalText()}", false))
|
||||
if (showEngine && engineLabel.isNotBlank())
|
||||
tiles.add(Tile("API", colFps, listOf(Span(engineLabel, colValue, valPx)),
|
||||
dxVersion().ifBlank { null }, false))
|
||||
if (displayServer.isNotBlank())
|
||||
tiles.add(Tile("DISPLAY", colDisp, listOf(Span(displayServer, colValue, valPx)),
|
||||
if (hdrState != DroidDeckHudHdr.NONE) hdrText() else null, false))
|
||||
if (showGpuModel && gpuNameText().isNotBlank())
|
||||
tiles.add(Tile("GPU", colGpu, gpuModelSpans(valPx, colValue), null, true))
|
||||
if (showBattery || showPower || showBatteryTemp) {
|
||||
val parts = ArrayList<Span>(); var any = false
|
||||
if (showBattery && s.battery.percent != null) { parts += numUnit(s.battery.percent.toString(), "%", valPx, unitPx); any = true }
|
||||
if (showBatteryTemp && s.battery.tempC != null) { if (any) parts += Span(" · ", colDim, subPx); parts += tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, valPx, unitPx); any = true }
|
||||
if (showPower && s.battery.watts > 0f) { if (any) parts += Span(" · ", colDim, subPx); parts += numUnit(fmt1(s.battery.watts), "W", valPx, unitPx); any = true }
|
||||
if (any) tiles.add(Tile("BAT", colBat, parts, null, true))
|
||||
private fun reading(key: String, s: HudMetrics.Snapshot, labelPx: Float, valuePx: Float, unitPx: Float): HudRow {
|
||||
if (key == "showFPSGraph") return HudRow(key, Span("", colDim, 0f), emptyList())
|
||||
val (label, color) = switchLabel(key)
|
||||
val values: List<Span> = when (key) {
|
||||
"showGpuModel" -> if (gpuNameText().isBlank()) numUnit(null, "", valuePx, unitPx)
|
||||
else gpuModelSpans(valuePx, colValue)
|
||||
"showGPULoad" -> numUnit(s.gpuPercent?.toString(), "%", valuePx, unitPx)
|
||||
"showGpuTemp" -> tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, valuePx, unitPx)
|
||||
"showCPUUsage" -> numUnit(s.cpuPercent?.toString(), "%", valuePx, unitPx)
|
||||
"showTemp" -> tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, valuePx, unitPx)
|
||||
"showBatteryTemp" -> tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, valuePx, unitPx)
|
||||
"showPower" -> numUnit(if (s.battery.watts > 0f) fmt1(s.battery.watts) else null, "W", valuePx, unitPx)
|
||||
"showBattery" -> numUnit(s.battery.percent?.toString(), "%", valuePx, unitPx)
|
||||
"showBatteryTime" -> valueUnit(s.battery.runtimeText ?: "—", valuePx, unitPx)
|
||||
"showVram" -> valueUnit(s.vramText() ?: "—", valuePx, unitPx)
|
||||
"showRAM" -> numUnit(s.ramPercent.roundToInt().toString(), "%", valuePx, unitPx)
|
||||
"showSwap" -> valueUnit(s.swapUsedText() ?: "—", valuePx, unitPx)
|
||||
"showNet" -> listOf(
|
||||
Span("↓", colDim, unitPx), Span(((s.netDownBps ?: 0L) / 1024L).toString(), colValue, valuePx),
|
||||
Span(" ↑", colDim, unitPx), Span(((s.netUpBps ?: 0L) / 1024L).toString(), colValue, valuePx),
|
||||
)
|
||||
"showPerCore" -> listOf(Span(s.perCorePercent.size.toString(), colValue, valuePx))
|
||||
"showFPS" -> glowing(numUnit(fpsText(fpsNow), "", valuePx, unitPx))
|
||||
"showLatency" -> numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", valuePx, unitPx)
|
||||
"showAvg" -> numUnit(fmt1(fpsAvg), "", valuePx, unitPx)
|
||||
"showLow1" -> numUnit(lowText(lows.low1Fps), "", valuePx, unitPx)
|
||||
"showLow01" -> numUnit(lowText(lows.low01Fps), "", valuePx, unitPx)
|
||||
"showLow001" -> numUnit(lowText(lows.low001Fps), "", valuePx, unitPx)
|
||||
"showEngine" -> listOf(Span(engineLabel.ifBlank { "—" }, colValue, valuePx))
|
||||
"showDisplay" -> listOf(Span(displayServer.ifBlank { "—" }, colDisp, valuePx))
|
||||
"showHdr" -> if (showHdrLine()) hdrValue(valuePx) else listOf(Span("off", colDim, valuePx))
|
||||
"showResolution" -> listOf(Span(resolutionString(), colValue, valuePx))
|
||||
"showProton" -> listOf(Span(wineVersion.ifBlank { "—" }, colVram, valuePx))
|
||||
"showSession" -> listOf(Span(elapsedString(), colValue, valuePx))
|
||||
else -> listOf(Span("—", colDim, valuePx))
|
||||
}
|
||||
if (tiles.isEmpty()) { contentW = 0f; contentH = 0f; return }
|
||||
|
||||
val keyH = lineH(keyPx); val valH = lineH(valPx); val subH = lineH(subPx)
|
||||
fun tileW(t: Tile) = max(max(measure(t.key, keyPx), runWidth(t.value)),
|
||||
t.sub?.let { measure(it, subPx) } ?: 0f) + innerPad * 2
|
||||
var normalW = 0f
|
||||
for (t in tiles) if (!t.wide) normalW = max(normalW, tileW(t))
|
||||
if (normalW == 0f) for (t in tiles) normalW = max(normalW, tileW(t) / 2f)
|
||||
val tileH = innerPad * 2 + keyH + lineGap + valH + lineGap + subH
|
||||
val fullW = normalW * 2 + tileGap
|
||||
|
||||
var x = pad; var y = pad; var col = 0
|
||||
fun place(t: Tile, tx: Float, ty: Float, tw: Float) {
|
||||
tileRects.add(RectF(tx, ty, tx + tw, ty + tileH))
|
||||
var by = ty + innerPad - ascent(keyPx)
|
||||
placeRun(tx + innerPad, by, listOf(Span(t.key, t.keyColor, keyPx)))
|
||||
by = ty + innerPad + keyH + lineGap - ascent(valPx)
|
||||
placeRun(tx + innerPad, by, t.value)
|
||||
if (t.sub != null) {
|
||||
by = ty + innerPad + keyH + lineGap + valH + lineGap - ascent(subPx)
|
||||
placeRun(tx + innerPad, by, listOf(Span(t.sub, colDim, subPx)))
|
||||
}
|
||||
}
|
||||
for (t in tiles) {
|
||||
if (t.wide) {
|
||||
if (col != 0) { y += tileH + tileGap; col = 0; x = pad }
|
||||
place(t, pad, y, fullW)
|
||||
y += tileH + tileGap; col = 0; x = pad
|
||||
} else {
|
||||
place(t, x, y, normalW)
|
||||
col++; x += normalW + tileGap
|
||||
if (col == 2) { col = 0; x = pad; y += tileH + tileGap }
|
||||
}
|
||||
}
|
||||
if (col != 0) y += tileH + tileGap
|
||||
if (showFPS && showGraph) {
|
||||
graphRect = RectF(pad, y, pad + fullW, y + sp(22f))
|
||||
y += sp(22f) + tileGap
|
||||
}
|
||||
contentW = pad + fullW + pad
|
||||
contentH = y + (pad - tileGap)
|
||||
addSubtleClock(pad)
|
||||
return HudRow(key, Span(label, color, labelPx), values.ifEmpty { listOf(Span("—", colDim, valuePx)) })
|
||||
}
|
||||
|
||||
private fun buildPill(s: HudMetrics.Snapshot) {
|
||||
val bigPx = sp(30f); val bigUnitPx = bigPx * 0.36f; val stkPx = sp(11.5f)
|
||||
val pad = sp(10f); val midGap = sp(12f); val stkLineGap = sp(3f)
|
||||
private fun buildRows(s: HudMetrics.Snapshot) {
|
||||
val st = size.style
|
||||
val pad = sp(st.pad); val lineGap = sp(st.lineGap); val lvGap = sp(st.labelGap)
|
||||
val gutter = sp(if (st.gutter > 0f) st.gutter else 14f)
|
||||
val unitPx = sp(if (st.unit > 0f) st.unit else st.row * 0.62f)
|
||||
val basePx = sp(if (st.sub > 0f) st.sub else st.row)
|
||||
|
||||
val left = ArrayList<Span>()
|
||||
val generating = differs(fpsNow)
|
||||
val fpsPx = if (generating) bigPx * 0.55f else bigPx
|
||||
left += Span(fpsText(fpsNow), colValue, fpsPx, glow = true)
|
||||
left += Span("fps", colDim, if (generating) bigUnitPx * 0.8f else bigUnitPx)
|
||||
|
||||
val stack = ArrayList<List<Span>>()
|
||||
val gpuName = if (showGpuModel && gpuNameText().isNotBlank()) gpuModelSpans(stkPx, colDim, compact = true) else null
|
||||
run {
|
||||
val l = ArrayList<Span>()
|
||||
if (showGPU && s.gpuPercent != null) { l += Span("GPU ${s.gpuPercent}%", colGpu, stkPx) }
|
||||
if (showCPU) { if (l.isNotEmpty()) l += Span(" · ", colDim, stkPx); l += Span("CPU ${s.cpuPercent ?: "—"}%", colCpu, stkPx) }
|
||||
if (l.isNotEmpty()) stack.add(l)
|
||||
val keys = size.rowsIn(storedOrder).filter { switchOn(it) }
|
||||
if (keys.isEmpty()) { contentW = 0f; contentH = 0f; return }
|
||||
val hero = (size == DroidDeckHudSize.PILL || size == DroidDeckHudSize.MINIMAL) && keys.firstOrNull() == "showFPS"
|
||||
val tiles = size == DroidDeckHudSize.TILES
|
||||
val bigPx = sp(st.row); val bigUnitPx = sp(st.unit)
|
||||
val heroSpans = listOf(
|
||||
Span(fpsText(fpsNow), colValue, bigPx, glow = true),
|
||||
Span("fps", colDim, bigUnitPx),
|
||||
)
|
||||
val listed = keys.filter { !hero || it != "showFPS" }.flatMap { key ->
|
||||
val labelPx = if (tiles) sp(st.key) else basePx
|
||||
val valuePx = if (tiles) sp(st.row) else basePx
|
||||
if (key == "showPerCore" && size == DroidDeckHudSize.MEGA)
|
||||
perCoreRows(s, labelPx, valuePx, unitPx)
|
||||
else listOf(reading(key, s, labelPx, valuePx, unitPx))
|
||||
}
|
||||
if (showRAM) stack.add(listOf(Span("RAM ${s.ramPercent.roundToInt()}%", colRam, stkPx)))
|
||||
if (showBattery || showPower || showBatteryTemp) {
|
||||
val l = ArrayList<Span>()
|
||||
fun part(spans: List<Span>) {
|
||||
l += if (l.isEmpty()) Span("BAT ", colBat, stkPx) else Span(" · ", colDim, stkPx)
|
||||
l += spans
|
||||
val maxCols = if (size == DroidDeckHudSize.MEGA) 3 else 2
|
||||
val cols = when {
|
||||
listed.size >= 9 -> maxCols
|
||||
listed.size >= 4 -> minOf(2, maxCols)
|
||||
else -> 1
|
||||
}
|
||||
|
||||
if (tiles) {
|
||||
val innerPad = sp(st.innerPad); val tileGap = sp(st.tileGap)
|
||||
val keyH = lineH(sp(st.key)); val valH = lineH(sp(st.row))
|
||||
val cellW = listed.maxOf { max(measure(it.label.text, it.label.sizePx), runWidth(it.vals)) } + innerPad * 2f
|
||||
val graphMin = if (listed.any { it.key == "showFPSGraph" }) sp(GRAPH_MIN_WIDTH_SP) else 0f
|
||||
val cellMin = graphMin + innerPad * 2f
|
||||
val cellH = innerPad * 2f + keyH + lineGap + valH
|
||||
for ((i, r) in listed.withIndex()) {
|
||||
val x = pad + (i % cols) * (cellW + tileGap)
|
||||
val y = pad + (i / cols) * (cellH + tileGap)
|
||||
tileRects.add(RectF(x, y, x + cellW, y + cellH))
|
||||
if (r.key == "showFPSGraph") {
|
||||
graphRect = RectF(x + innerPad, y + innerPad, x + max(cellW, cellMin) - innerPad, y + cellH - innerPad)
|
||||
continue
|
||||
}
|
||||
placeRun(x + innerPad, y + innerPad - ascent(r.label.sizePx), listOf(r.label))
|
||||
placeRun(x + innerPad, y + innerPad + keyH + lineGap - ascent(sp(st.row)), r.vals)
|
||||
}
|
||||
if (showBattery && s.battery.percent != null) part(listOf(Span("${s.battery.percent}%", colBat, stkPx)))
|
||||
if (showBatteryTemp && s.battery.tempC != null)
|
||||
part(tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, stkPx, stkPx * 0.62f))
|
||||
if (showPower && s.battery.watts > 0f) part(listOf(Span("${fmt1(s.battery.watts)}W", colDim, stkPx)))
|
||||
if (l.isNotEmpty()) stack.add(l)
|
||||
}
|
||||
run {
|
||||
val l = ArrayList<Span>()
|
||||
l += Span("${fmt1(1000f / max(fpsNow, 1f))}ms", colDim, stkPx)
|
||||
if (displayServer.isNotBlank()) { l += Span(" · ", colDim, stkPx); l += Span(displayServer, colDisp, stkPx) }
|
||||
if (showVram && s.vramText() != null) { l += Span(" · ", colDim, stkPx); l += Span("${s.vramText()} vram", colDim, stkPx) }
|
||||
stack.add(l)
|
||||
}
|
||||
if (hdrState != DroidDeckHudHdr.NONE) stack.add(hdrLine(stkPx))
|
||||
|
||||
var statsW = 0f
|
||||
for (l in stack) statsW = max(statsW, runWidth(l))
|
||||
val nameOnTop = gpuName != null && runWidth(gpuName) > statsW
|
||||
if (gpuName != null && !nameOnTop) stack.add(0, gpuName)
|
||||
|
||||
val apiStr = apiLabel()
|
||||
val hasApi = apiStr != "FPS"
|
||||
val apiH = if (hasApi) lineH(stkPx) else 0f
|
||||
val apiGap = if (hasApi) stkLineGap else 0f
|
||||
|
||||
val leftW = runWidth(left); val leftH = lineH(bigPx)
|
||||
val apiW = if (hasApi) measure(apiStr, stkPx) else 0f
|
||||
val leftBlockW = max(leftW, apiW)
|
||||
val leftColH = apiH + apiGap + leftH
|
||||
val stkH = lineH(stkPx)
|
||||
var stackW = 0f
|
||||
for (l in stack) stackW = max(stackW, runWidth(l))
|
||||
val stackTotalH = stack.size * stkH + (stack.size - 1).coerceAtLeast(0) * stkLineGap
|
||||
val innerH = max(leftColH, stackTotalH)
|
||||
val topLineH = if (nameOnTop) stkH + stkLineGap else 0f
|
||||
contentW = pad + leftBlockW + midGap + stackW + pad
|
||||
contentH = pad + topLineH + innerH + pad
|
||||
|
||||
var ly = pad + topLineH + (innerH - leftColH) / 2f
|
||||
if (hasApi) {
|
||||
placeRun(pad, ly - ascent(stkPx), listOf(Span(apiStr, colFps, stkPx)))
|
||||
ly += apiH + apiGap
|
||||
}
|
||||
placeRun(pad, ly - ascent(bigPx), left)
|
||||
var sy = pad + topLineH + (innerH - stackTotalH) / 2f
|
||||
for (l in stack) {
|
||||
placeRun(pad + leftBlockW + midGap, sy - ascent(stkPx), l)
|
||||
sy += stkH + stkLineGap
|
||||
}
|
||||
addSubtleClock(pad, leftAligned = true)
|
||||
if (nameOnTop && gpuName != null) {
|
||||
val end = placeRun(pad, pad - ascent(stkPx), gpuName)
|
||||
contentW = max(contentW, end + pad)
|
||||
val lines = (listed.size + cols - 1) / cols
|
||||
contentW = pad + cols * (cellW + tileGap) - tileGap + pad
|
||||
contentH = pad + lines * (cellH + tileGap) - tileGap + pad
|
||||
} else {
|
||||
val columns = (0 until cols).map { c -> listed.filterIndexed { i, _ -> i % cols == c } }
|
||||
val labelW = columns.map { col -> col.maxOfOrNull { measure(it.label.text, it.label.sizePx) } ?: 0f }
|
||||
val colW = columns.mapIndexed { c, col ->
|
||||
val body = if (col.isEmpty()) 0f else labelW[c] + lvGap + (col.maxOfOrNull { runWidth(it.vals) } ?: 0f)
|
||||
val graph = if (col.any { it.key == "showFPSGraph" }) sp(GRAPH_MIN_WIDTH_SP) + labelW[c] + lvGap else 0f
|
||||
max(body, graph)
|
||||
}
|
||||
val gaps = (0 until cols).count { columns[it].isNotEmpty() }.coerceAtLeast(1) - 1
|
||||
val bodyW = colW.sum() + gutter * gaps
|
||||
var bodyH = 0f
|
||||
for (col in columns) {
|
||||
var y = 0f
|
||||
for (r in col) y += rowHeight(r) + lineGap
|
||||
if (col.isNotEmpty()) bodyH = max(bodyH, y - lineGap)
|
||||
}
|
||||
val heroW = if (hero) runWidth(heroSpans) else 0f
|
||||
val heroH = if (hero) lineH(bigPx) else 0f
|
||||
val x0 = pad + if (hero && listed.isNotEmpty()) heroW + gutter else 0f
|
||||
val top = pad + (max(bodyH, heroH) - bodyH) / 2f
|
||||
var x = x0
|
||||
for (c in 0 until cols) {
|
||||
if (columns[c].isEmpty()) continue
|
||||
var y = top
|
||||
for (r in columns[c]) {
|
||||
if (r.key == "showFPSGraph") {
|
||||
val left = x + labelW[c] + lvGap
|
||||
graphRect = RectF(left, y, max(x + colW[c], left + sp(GRAPH_MIN_WIDTH_SP)), y + sp(GRAPH_HEIGHT_SP))
|
||||
y += sp(GRAPH_HEIGHT_SP) + lineGap
|
||||
continue
|
||||
}
|
||||
val px = maxOf(r.label.sizePx, r.vals.maxOfOrNull { it.sizePx } ?: 0f)
|
||||
val baseline = y - ascent(px)
|
||||
placeRun(x, baseline, listOf(r.label))
|
||||
placeRun(x + labelW[c] + lvGap, baseline, r.vals)
|
||||
y += lineH(px) + lineGap
|
||||
}
|
||||
x += colW[c] + gutter
|
||||
}
|
||||
if (hero) {
|
||||
val baseline = pad + (max(bodyH, heroH) - heroH) / 2f - ascent(bigPx)
|
||||
placeRun(pad, baseline, heroSpans, glow = true)
|
||||
}
|
||||
contentW = max(x0 + bodyW, pad + heroW) + pad
|
||||
contentH = pad + max(bodyH, heroH) + pad
|
||||
}
|
||||
}
|
||||
|
||||
private fun buildMinimal(s: HudMetrics.Snapshot) {
|
||||
val bigPx = sp(34f); val bigUnitPx = bigPx * 0.32f; val subPx = sp(11.5f); val footPx = sp(9.5f)
|
||||
val stroke = outlineWidth()
|
||||
val left = contentLeft()
|
||||
val inner = panelInset() + stroke
|
||||
private fun rowHeight(r: HudRow): Float =
|
||||
if (r.key == "showFPSGraph") sp(GRAPH_HEIGHT_SP)
|
||||
else lineH(maxOf(r.label.sizePx, r.vals.maxOfOrNull { it.sizePx } ?: 0f))
|
||||
|
||||
val minGenerating = differs(fpsNow)
|
||||
val big = listOf(
|
||||
Span(fpsText(fpsNow), colValue, if (minGenerating) bigPx * 0.55f else bigPx),
|
||||
Span("fps", colDim, if (minGenerating) bigUnitPx * 0.8f else bigUnitPx))
|
||||
val sub = ArrayList<Span>()
|
||||
fun low(label: String, value: Float) {
|
||||
if (sub.isNotEmpty()) sub += Span(" · ", colDim, subPx)
|
||||
sub += Span("$label ", colDim, subPx)
|
||||
sub += Span(lowText(value) ?: "—", colFps, subPx)
|
||||
private fun perCoreRows(s: HudMetrics.Snapshot, labelPx: Float, valuePx: Float, unitPx: Float): List<HudRow> {
|
||||
val pct = s.perCorePercent
|
||||
val clk = s.perCoreClockMhz
|
||||
return (0 until max(pct.size, clk.size)).map { i ->
|
||||
val vals = ArrayList<Span>()
|
||||
vals += numUnit(if (i < pct.size && pct[i] >= 0) pct[i].toString() else null, "%", valuePx, unitPx)
|
||||
vals += Span(" ", colDim, unitPx)
|
||||
vals += numUnit(if (i < clk.size && clk[i] > 0) clk[i].toString() else null, "MHz", valuePx, unitPx)
|
||||
HudRow("showPerCore", Span("C$i", colCpu, labelPx), vals)
|
||||
}
|
||||
if (showLow1) low("1%", lows.low1Fps)
|
||||
if (showLow01) low("0.1%", lows.low01Fps)
|
||||
if (showLow001) low("0.01%", lows.low001Fps)
|
||||
val footerLabel = listOf(if (showEngine) engineLabel else "", displayServer)
|
||||
.filter { it.isNotBlank() }.joinToString(" · ")
|
||||
val hdr = if (hdrState != DroidDeckHudHdr.NONE) hdrLine(footPx) else emptyList()
|
||||
|
||||
val (headerBottom, headerRight) = addPanelHeader(left, inner)
|
||||
val x = headerRight
|
||||
|
||||
val colW = maxOf(runWidth(big), runWidth(sub), x - left,
|
||||
max(measure(footerLabel, footPx), runWidth(hdr)), if (showGraph) sp(120f) else 0f)
|
||||
val bigBase = headerBottom + sp(8f) + capHeight(big[0].sizePx)
|
||||
placeRun(left - inkLeft(big[0].text, big[0].sizePx), bigBase, big, glow = true)
|
||||
var last = bigBase
|
||||
if (sub.isNotEmpty()) {
|
||||
last += sp(10f) + capHeight(subPx)
|
||||
placeRun(left - inkLeft(sub[0].text, subPx), last, sub)
|
||||
}
|
||||
if (showGraph) {
|
||||
val top = last + sp(9f)
|
||||
graphRect = RectF(left, top, left + colW, top + sp(24f))
|
||||
last = top + sp(24f)
|
||||
}
|
||||
if (footerLabel.isNotBlank()) {
|
||||
val base = last + sp(8f) + capHeight(footPx)
|
||||
glyphs.add(Glyph(left - inkLeft(footerLabel, footPx), base, footerLabel, blend(colDim), footPx))
|
||||
last = base
|
||||
}
|
||||
if (hdr.isNotEmpty()) {
|
||||
val base = last + sp(6f) + capHeight(footPx)
|
||||
placeRun(left - inkLeft(hdr[0].text, footPx), base, hdr)
|
||||
last = base
|
||||
}
|
||||
measurePaint.textSize = footPx
|
||||
val panel = RectF(panelLeft(), panelInset(), left + colW + sp(34f), last + measurePaint.fontMetrics.descent + sp(9f) + stroke)
|
||||
|
||||
finishPanel(panel, halfRound = true)
|
||||
}
|
||||
|
||||
private fun buildStrip(s: HudMetrics.Snapshot) {
|
||||
@@ -1046,66 +942,27 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
}
|
||||
|
||||
val generating = differs(fpsNow)
|
||||
val fps = ArrayList<Span>()
|
||||
if (apiLabel() != "FPS") fps += Span("${apiLabel()} ", colDim, rowPx)
|
||||
fps += Span(fpsText(fpsNow), colValue, if (generating) fpsPx * 0.8f else fpsPx, glow = true)
|
||||
fps += Span("fps", colDim, unitPx)
|
||||
x = placeRun(x, baseline, fps) + groupGap
|
||||
|
||||
if (showGraph) {
|
||||
val gw = sp(72f); val gh = h * 0.55f
|
||||
if (x + gw <= right) {
|
||||
for (key in size.rowsIn(storedOrder)) {
|
||||
if (!switchOn(key)) continue
|
||||
if (key == "showFPSGraph") {
|
||||
val gw = sp(72f); val gh = h * 0.55f
|
||||
if (x + gw > right) break
|
||||
graphRect = RectF(x, mid - gh / 2f, x + gw, mid + gh / 2f)
|
||||
x += gw + groupGap
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
val groups = ArrayList<List<Span>>()
|
||||
run {
|
||||
val l = ArrayList<Span>()
|
||||
fun low(label: String, value: Float) {
|
||||
if (l.isNotEmpty()) l += Span(" ", colDim, rowPx)
|
||||
l += Span("$label ", colDim, rowPx)
|
||||
l += Span(lowText(value) ?: "—", colFps, rowPx)
|
||||
val spans = if (key == "showFPS") {
|
||||
val fps = ArrayList<Span>()
|
||||
if (apiLabel() != "FPS") fps += Span("${apiLabel()} ", colDim, rowPx)
|
||||
fps += Span(fpsText(fpsNow), colValue, if (generating) fpsPx * 0.8f else fpsPx, glow = true)
|
||||
fps += Span("fps", colDim, unitPx)
|
||||
fps
|
||||
} else {
|
||||
val row = reading(key, s, rowPx, rowPx, unitPx)
|
||||
listOf(row.label, Span(" ", colDim, rowPx)) + row.vals
|
||||
}
|
||||
if (showLow1) low("1%", lows.low1Fps)
|
||||
if (showLow01) low("0.1%", lows.low01Fps)
|
||||
if (showLow001) low("0.01%", lows.low001Fps)
|
||||
if (l.isNotEmpty()) groups += l
|
||||
}
|
||||
if (showGPU || showGpuTemp) {
|
||||
val l = arrayListOf(Span("GPU", colGpu, rowPx))
|
||||
if (showGPU) l += Span(" ${s.gpuPercent ?: "—"}%", colGpu, rowPx)
|
||||
if (showGpuTemp && s.gpuTempC != null) { l += Span(" ", colDim, rowPx); l += tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, rowPx, unitPx) }
|
||||
groups += l
|
||||
}
|
||||
if (showCPU || showCpuTemp) {
|
||||
val l = arrayListOf(Span("CPU", colCpu, rowPx))
|
||||
if (showCPU) l += Span(" ${s.cpuPercent ?: "—"}%", colCpu, rowPx)
|
||||
if (showCpuTemp && s.cpuTempC != null) { l += Span(" ", colDim, rowPx); l += tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, rowPx, unitPx) }
|
||||
groups += l
|
||||
}
|
||||
if (showVram) s.vramText()?.let { groups += listOf(Span("VRAM $it", colVram, rowPx)) }
|
||||
if (showRAM) groups += listOf(Span("RAM ${s.ramPercent.roundToInt()}%", colRam, rowPx))
|
||||
if (showBattery || showPower || showBatteryTemp) {
|
||||
val l = ArrayList<Span>()
|
||||
fun part(spans: List<Span>) {
|
||||
l += if (l.isEmpty()) Span("BAT ", colBat, rowPx) else Span(" ", colDim, rowPx)
|
||||
l += spans
|
||||
}
|
||||
if (showBattery && s.battery.percent != null) part(listOf(Span("${s.battery.percent}%", colBat, rowPx)))
|
||||
if (showBatteryTemp && s.battery.tempC != null)
|
||||
part(tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, rowPx, unitPx))
|
||||
if (showPower && s.battery.watts > 0f) part(listOf(Span("${fmt1(s.battery.watts)}W", colDim, rowPx)))
|
||||
if (l.isNotEmpty()) groups += l
|
||||
}
|
||||
if (displayServer.isNotBlank()) groups += listOf(Span(displayServer, colDisp, rowPx))
|
||||
if (hdrState != DroidDeckHudHdr.NONE) groups += hdrLine(rowPx)
|
||||
if (showGpuModel && gpuNameText().isNotBlank()) groups += gpuModelSpans(rowPx, colDim, compact = true)
|
||||
|
||||
for (g in groups) {
|
||||
if (x + runWidth(g) > right) break
|
||||
x = placeRun(x, baseline, g) + groupGap
|
||||
if (x + runWidth(spans) > right) break
|
||||
x = placeRun(x, baseline, spans) + groupGap
|
||||
}
|
||||
|
||||
stripRect = RectF(0f, 0f, w, h)
|
||||
@@ -1125,168 +982,6 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
return inkRect.left.toFloat()
|
||||
}
|
||||
|
||||
private fun layoutColumn(rows: List<HudRow>, x: Float, y0: Float,
|
||||
rowPx: Float, lineGap: Float, lvGap: Float): Pair<Float, Float> {
|
||||
if (rows.isEmpty()) return Pair(y0, x)
|
||||
var labelCol = 0f
|
||||
for (r in rows) if (!r.inline) labelCol = max(labelCol, measure(r.label.text, rowPx))
|
||||
val h = lineH(rowPx); val asc = ascent(rowPx)
|
||||
var y = y0; var right = x
|
||||
for (r in rows) {
|
||||
val baseline = y - asc
|
||||
placeRun(x, baseline, listOf(r.label))
|
||||
val valX = if (r.inline) x + measure(r.label.text, rowPx) + lvGap
|
||||
else x + labelCol + lvGap
|
||||
val end = placeRun(valX, baseline, r.vals)
|
||||
right = max(right, end)
|
||||
y += h + lineGap
|
||||
}
|
||||
return Pair(y - lineGap, right)
|
||||
}
|
||||
|
||||
private fun layoutWrap(fragments: List<List<Span>>, x: Float, y0: Float, maxWidth: Float,
|
||||
px: Float, lineGap: Float): Pair<Float, Float> {
|
||||
if (fragments.isEmpty()) return Pair(y0, x)
|
||||
val h = lineH(px); val asc = ascent(px)
|
||||
val sepW = measure(" · ", px)
|
||||
var cx = x; var y = y0; var right = x; var firstOnLine = true
|
||||
for (frag in fragments) {
|
||||
val w = runWidth(frag)
|
||||
if (!firstOnLine && (cx + sepW + w - x) > maxWidth) { y += h + lineGap; cx = x; firstOnLine = true }
|
||||
if (!firstOnLine) { placeRun(cx, y - asc, listOf(Span(" · ", colDim, px))); cx += sepW }
|
||||
val end = placeRun(cx, y - asc, frag)
|
||||
cx = end; right = max(right, end); firstOnLine = false
|
||||
}
|
||||
return Pair(y + h, right)
|
||||
}
|
||||
|
||||
private fun buildMega(s: HudMetrics.Snapshot) {
|
||||
val rowPx = sp(11.5f); val unitPx = rowPx * 0.62f; val bandPx = sp(9.5f)
|
||||
val pad = sp(10f); val lineGap = sp(3.5f); val lvGap = sp(7f); val gutter = sp(16f)
|
||||
|
||||
val left = ArrayList<HudRow>()
|
||||
if (showGpuModel && gpuNameText().isNotBlank())
|
||||
left.add(HudRow(Span("GPU", colGpu, rowPx), gpuModelSpans(rowPx, colValue)))
|
||||
if (showGPU && hasGpuStats(s)) {
|
||||
val v = ArrayList<Span>()
|
||||
v += numUnit(s.gpuPercent?.toString(), "%", rowPx, unitPx)
|
||||
if (showGpuTemp) tempSpans(s.gpuTempC, HudMetrics.TempSensor.GPU, rowPx, unitPx)
|
||||
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
|
||||
v += gap(unitPx); v += numUnit(s.gpuClockMhz?.toString(), "MHz", rowPx, unitPx)
|
||||
left.add(HudRow(Span("GPU", colGpu, rowPx), v))
|
||||
}
|
||||
if (showCPU) {
|
||||
val v = ArrayList<Span>()
|
||||
v += numUnit(s.cpuPercent?.toString(), "%", rowPx, unitPx)
|
||||
v += gap(unitPx); v += numUnit(s.cpuClockMhz?.toString(), "MHz", rowPx, unitPx)
|
||||
if (showCpuTemp) tempSpans(s.cpuTempC, HudMetrics.TempSensor.CPU, rowPx, unitPx)
|
||||
.let { if (it.isNotEmpty()) { v += gap(unitPx); v += it } }
|
||||
left.add(HudRow(Span("CPU", colCpu, rowPx), v))
|
||||
}
|
||||
if (showPerCore) {
|
||||
val pct = s.perCorePercent; val clk = s.perCoreClockMhz
|
||||
val n = max(pct.size, clk.size)
|
||||
for (i in 0 until n) {
|
||||
val v = ArrayList<Span>()
|
||||
v += numUnit(if (i < pct.size && pct[i] >= 0) pct[i].toString() else null, "%", rowPx, unitPx)
|
||||
v += gap(unitPx)
|
||||
v += numUnit(if (i < clk.size && clk[i] > 0) clk[i].toString() else null, "MHz", rowPx, unitPx)
|
||||
left.add(HudRow(Span("C$i", colCpu, rowPx), v))
|
||||
}
|
||||
}
|
||||
|
||||
val right = ArrayList<HudRow>()
|
||||
if (showVram && s.vramText() != null)
|
||||
right.add(HudRow(Span("VRAM", colVram, rowPx), valueUnit(s.vramText()!!, rowPx, unitPx)))
|
||||
if (showRAM) {
|
||||
val v = ArrayList<Span>()
|
||||
v += valueUnit(s.ramUsedText(), rowPx, unitPx)
|
||||
v += Span("/", colDim, unitPx); v += valueUnit(s.ramTotalText(), rowPx, unitPx)
|
||||
v += gap(unitPx); v += numUnit(s.ramPercent.roundToInt().toString(), "%", rowPx, unitPx)
|
||||
right.add(HudRow(Span("RAM", colRam, rowPx), v))
|
||||
}
|
||||
if (showSwap && s.swapUsedText() != null) {
|
||||
val v = ArrayList<Span>()
|
||||
v += valueUnit(s.swapUsedText()!!, rowPx, unitPx)
|
||||
s.swapTotalText()?.let { v += Span("/", colDim, unitPx); v += valueUnit(it, rowPx, unitPx) }
|
||||
right.add(HudRow(Span("SWP", colRam, rowPx), v))
|
||||
}
|
||||
if (showNet && s.netDownBps != null) {
|
||||
val d = (s.netDownBps ?: 0L) / 1024L
|
||||
val u = (s.netUpBps ?: 0L) / 1024L
|
||||
val v = ArrayList<Span>()
|
||||
v += Span("↓", colDim, unitPx); v += Span(d.toString(), colValue, rowPx)
|
||||
v += Span(" ↑", colDim, unitPx); v += Span(u.toString(), colValue, rowPx)
|
||||
v += Span("KB/s", colDim, unitPx)
|
||||
right.add(HudRow(Span("NET", colFps, rowPx), v))
|
||||
}
|
||||
if (showBattery || showPower || showBatteryTemp) {
|
||||
val v = ArrayList<Span>(); var any = false
|
||||
if (showBattery && s.battery.percent != null) { v += numUnit(s.battery.percent.toString(), "%", rowPx, unitPx); any = true }
|
||||
if (showBatteryTemp) tempSpans(s.battery.tempC, HudMetrics.TempSensor.BATTERY, rowPx, unitPx)
|
||||
.let { if (it.isNotEmpty()) { if (any) v += gap(unitPx); v += it; any = true } }
|
||||
if (showPower && s.battery.watts > 0f) { if (any) v += gap(unitPx); v += numUnit(fmt1(s.battery.watts), "W", rowPx, unitPx); any = true }
|
||||
if (any) right.add(HudRow(Span("BAT", colBat, rowPx), v))
|
||||
}
|
||||
if (showFPS) {
|
||||
val v = ArrayList<Span>()
|
||||
v += glowing(numUnit(fpsText(fpsNow), "FPS", rowPx, unitPx))
|
||||
v += gap(unitPx); v += numUnit(fmt1(1000f / max(fpsNow, 1f)), "ms", rowPx, unitPx)
|
||||
right.add(HudRow(Span(apiLabel(), colFps, rowPx), v))
|
||||
right.add(HudRow(Span("AVG", colLo, rowPx), numUnit(fmt1(fpsAvg), "FPS", rowPx, unitPx)))
|
||||
if (showLow1)
|
||||
right.add(HudRow(Span("1%", colLo, rowPx), numUnit(lowText(lows.low1Fps), "FPS", rowPx, unitPx)))
|
||||
if (showLow01)
|
||||
right.add(HudRow(Span("0.1%", colLo, rowPx), numUnit(lowText(lows.low01Fps), "FPS", rowPx, unitPx)))
|
||||
if (showLow001)
|
||||
right.add(HudRow(Span("0.01%", colLo, rowPx), numUnit(lowText(lows.low001Fps), "FPS", rowPx, unitPx)))
|
||||
}
|
||||
|
||||
val (leftBottom, leftRight) = layoutColumn(left, pad, pad, rowPx, lineGap, lvGap)
|
||||
val rightX = (if (left.isEmpty()) pad else leftRight + gutter)
|
||||
val (rightBottom, rightRight) = layoutColumn(right, rightX, pad, rowPx, lineGap, lvGap)
|
||||
var y = max(leftBottom, rightBottom)
|
||||
var maxRight = max(leftRight, rightRight)
|
||||
|
||||
val band = ArrayList<List<Span>>()
|
||||
if (showResolution) band.add(listOf(Span("RES ", colDim, bandPx), Span(resolutionString(), colValue, bandPx)))
|
||||
if (displayServer.isNotBlank()) band.add(listOf(Span("DISP ", colDim, bandPx), Span(displayServer, colDisp, bandPx)))
|
||||
if (hdrState != DroidDeckHudHdr.NONE) band.add(listOf(Span("HDR ", colDim, bandPx)) + hdrValue(bandPx))
|
||||
if (showProton && wineVersion.isNotBlank()) band.add(listOf(Span(wineVersion, colVram, bandPx)))
|
||||
if (showSession) band.add(listOf(Span("elapsed ", colDim, bandPx), Span(elapsedString(), colValue, bandPx)))
|
||||
if (band.isNotEmpty()) {
|
||||
y += sp(4f)
|
||||
val (bBottom, bRight) = layoutWrap(band, pad, y, max(maxRight - pad, sp(180f)), bandPx, lineGap)
|
||||
y = bBottom; maxRight = max(maxRight, bRight)
|
||||
}
|
||||
|
||||
if (showGraph) {
|
||||
y += sp(3f)
|
||||
val gh = sp(22f)
|
||||
val gr = max(maxRight, pad + sp(220f))
|
||||
graphRect = RectF(pad, y, gr, y + gh)
|
||||
maxRight = max(maxRight, gr)
|
||||
y += gh
|
||||
}
|
||||
|
||||
val dxLine = dxVersionLabeled()
|
||||
val hasDx = showDxVer && dxLine.isNotBlank()
|
||||
if (hasDx) {
|
||||
y += sp(4f)
|
||||
maxRight = max(maxRight, placeRun(pad, y - ascent(bandPx), listOf(Span(dxLine, colDim, bandPx))))
|
||||
y += lineH(bandPx)
|
||||
}
|
||||
if (showWrapper && graphicsWrapper.isNotBlank()) {
|
||||
y += if (hasDx) sp(1f) else sp(4f)
|
||||
maxRight = max(maxRight, placeRun(pad, y - ascent(bandPx), listOf(Span(graphicsWrapper, colDim, bandPx))))
|
||||
y += lineH(bandPx)
|
||||
}
|
||||
|
||||
contentW = maxRight + pad
|
||||
contentH = y + pad
|
||||
addSubtleClock(pad)
|
||||
}
|
||||
|
||||
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
|
||||
if (stripRect != null) { setMeasuredDimension(contentW.roundToInt(), resolveSize(contentH.roundToInt(), heightMeasureSpec)); return }
|
||||
setMeasuredDimension(
|
||||
@@ -1567,6 +1262,8 @@ class DroidDeckHudView(context: Context) : View(context) {
|
||||
const val MIN_SCALE = 0.5f
|
||||
const val MAX_SCALE = 2f
|
||||
const val GRAPH_CLIP_MS = 49.9f
|
||||
const val GRAPH_HEIGHT_SP = 22f
|
||||
const val GRAPH_MIN_WIDTH_SP = 160f
|
||||
|
||||
fun parseIntOr(s: String?, d: Int): Int = try { s?.trim()?.toInt() ?: d } catch (e: Exception) { d }
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package com.droiddeck.launcher.hud
|
||||
|
||||
import java.io.File
|
||||
import java.io.RandomAccessFile
|
||||
import kotlin.math.roundToInt
|
||||
|
||||
internal class FrameStats {
|
||||
@@ -159,7 +160,11 @@ internal class FrameStats {
|
||||
}
|
||||
}
|
||||
|
||||
internal class GameFrameFeed(private val file: File, val stats: FrameStats = FrameStats()) {
|
||||
internal class GameFrameFeed(
|
||||
private val file: File,
|
||||
val stats: FrameStats = FrameStats(),
|
||||
private val clockControl: File? = null,
|
||||
) {
|
||||
private var handle = 0L
|
||||
private var nextOpenNs = 0L
|
||||
private var lastRingFrameNs = 0L
|
||||
@@ -171,6 +176,8 @@ internal class GameFrameFeed(private val file: File, val stats: FrameStats = Fra
|
||||
private var lastCompositorNs = 0L
|
||||
@Volatile private var compositorFrames = 0L
|
||||
private var seenCompositorFrames = 0L
|
||||
private var clockShiftNs = 0L
|
||||
private var clockShiftReadNs = Long.MIN_VALUE
|
||||
|
||||
@Volatile var engine = ""
|
||||
private set
|
||||
@@ -199,6 +206,9 @@ internal class GameFrameFeed(private val file: File, val stats: FrameStats = Fra
|
||||
}
|
||||
val n = HudFrames.nativePoll(handle, frametimes, times)
|
||||
if (n > 0) {
|
||||
var shift = guestClockShift(nowNs, SHIFT_NS)
|
||||
if (nowNs - (times[n - 1] + shift) > LIVE_NS) shift = guestClockShift(nowNs, SHIFT_RECHECK_NS)
|
||||
for (i in 0 until n) times[i] += shift
|
||||
if (!fromGamescope) {
|
||||
stats.reset()
|
||||
fromGamescope = true
|
||||
@@ -216,6 +226,16 @@ internal class GameFrameFeed(private val file: File, val stats: FrameStats = Fra
|
||||
return n > 0 || compositorAdded
|
||||
}
|
||||
|
||||
internal fun guestClockShift(nowNs: Long, maxAgeNs: Long): Long {
|
||||
val control = clockControl ?: return 0L
|
||||
if (clockShiftReadNs != Long.MIN_VALUE && nowNs - clockShiftReadNs < maxAgeNs) return clockShiftNs
|
||||
clockShiftReadNs = nowNs
|
||||
clockShiftNs = runCatching {
|
||||
RandomAccessFile(control, "r").use { if (it.length() < Long.SIZE_BYTES) 0L else java.lang.Long.reverseBytes(it.readLong()) }
|
||||
}.getOrDefault(0L).coerceAtLeast(0L)
|
||||
return clockShiftNs
|
||||
}
|
||||
|
||||
fun onCompositorFrame(nowNs: Long) {
|
||||
if (fromGamescope) {
|
||||
lastCompositorNs = 0L
|
||||
@@ -253,6 +273,11 @@ internal class GameFrameFeed(private val file: File, val stats: FrameStats = Fra
|
||||
private const val LIVE_NS = 2_000_000_000L
|
||||
private const val STALE_NS = 5_000_000_000L
|
||||
private const val INFO_NS = 500_000_000L
|
||||
private const val SHIFT_NS = 1_000_000_000L
|
||||
private const val SHIFT_RECHECK_NS = 100_000_000L
|
||||
private const val CLOCK_CONTROL_PATH = "tmp/.bl-clock"
|
||||
|
||||
fun forRoot(root: File) = GameFrameFeed(File(root, HudFrames.PATH), clockControl = File(root, CLOCK_CONTROL_PATH))
|
||||
|
||||
fun engineLabel(name: String): String = when (name) {
|
||||
"DXVK" -> "DXVK"
|
||||
|
||||
@@ -50,6 +50,7 @@ public class HudLockController {
|
||||
private final Callbacks cb;
|
||||
private final GestureDetector detector;
|
||||
private final ScaleGestureDetector scaleDetector;
|
||||
private final android.view.VelocityTracker velocity = android.view.VelocityTracker.obtain();
|
||||
|
||||
private boolean locked = false;
|
||||
|
||||
@@ -86,8 +87,18 @@ public class HudLockController {
|
||||
public boolean onTouchEvent(MotionEvent event) {
|
||||
scaleDetector.onTouchEvent(event);
|
||||
detector.onTouchEvent(event);
|
||||
// The HUD moves under the finger, so the throw is measured on the screen, not in the HUD.
|
||||
MotionEvent onScreen = MotionEvent.obtain(event);
|
||||
onScreen.setLocation(event.getRawX(), event.getRawY());
|
||||
if (event.getActionMasked() == MotionEvent.ACTION_DOWN) velocity.clear();
|
||||
velocity.addMovement(onScreen);
|
||||
onScreen.recycle();
|
||||
int action = event.getActionMasked();
|
||||
if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
|
||||
if (dragging && !locked && !pinched && action == MotionEvent.ACTION_UP) {
|
||||
velocity.computeCurrentVelocity(1000);
|
||||
cb.onFlung(velocity.getXVelocity(), velocity.getYVelocity());
|
||||
}
|
||||
if (dragging && !locked) cb.onMoved(view.getX(), view.getY());
|
||||
dragging = false;
|
||||
}
|
||||
@@ -124,12 +135,6 @@ public class HudLockController {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
|
||||
if (dragging && !locked && !pinched) cb.onFlung(velocityX, velocityY);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
|
||||
if (pinched) return true;
|
||||
|
||||
@@ -14,6 +14,8 @@
|
||||
|
||||
package com.droiddeck.launcher.hud;
|
||||
|
||||
import com.droiddeck.launcher.session.BatteryRuntimeEstimator;
|
||||
|
||||
import android.app.ActivityManager;
|
||||
import android.content.Context;
|
||||
import android.content.Intent;
|
||||
@@ -560,10 +562,9 @@ public class HudMetrics {
|
||||
return sawSignal;
|
||||
}
|
||||
|
||||
private Double smoothedBatteryRuntimeHours = null;
|
||||
private static final double MAX_RUNTIME_HOURS = 72.0;
|
||||
private static final double RUNTIME_SMOOTHING_OLD_WEIGHT = 0.65;
|
||||
private static final double RUNTIME_SMOOTHING_NEW_WEIGHT = 0.35;
|
||||
private final BatteryRuntimeEstimator batteryRuntimeEstimator = new BatteryRuntimeEstimator();
|
||||
private Boolean lastBatteryDischarging = null;
|
||||
private Boolean lastBatteryCharging = null;
|
||||
|
||||
public Battery collectBattery() {
|
||||
BatteryManager bm = (BatteryManager) context.getSystemService(Context.BATTERY_SERVICE);
|
||||
@@ -581,11 +582,22 @@ public class HudMetrics {
|
||||
|
||||
int st = status.getIntExtra(BatteryManager.EXTRA_STATUS, BatteryManager.BATTERY_STATUS_UNKNOWN);
|
||||
boolean charging = st == BatteryManager.BATTERY_STATUS_CHARGING || st == BatteryManager.BATTERY_STATUS_FULL;
|
||||
boolean discharging = st == BatteryManager.BATTERY_STATUS_DISCHARGING
|
||||
|| st == BatteryManager.BATTERY_STATUS_NOT_CHARGING;
|
||||
if (lastBatteryDischarging != null && lastBatteryDischarging.booleanValue() != discharging) {
|
||||
batteryRuntimeEstimator.reset();
|
||||
}
|
||||
lastBatteryDischarging = discharging;
|
||||
if (st == BatteryManager.BATTERY_STATUS_UNKNOWN) {
|
||||
Boolean sysCharging = readChargingFromPowerSupply();
|
||||
if (sysCharging != null) charging = sysCharging;
|
||||
}
|
||||
long currentMicroAmps = Math.abs(bm.getLongProperty(BatteryManager.BATTERY_PROPERTY_CURRENT_NOW));
|
||||
if (lastBatteryCharging != null
|
||||
&& lastBatteryCharging.booleanValue() != charging) {
|
||||
batteryRuntimeEstimator.reset();
|
||||
}
|
||||
lastBatteryCharging = charging;
|
||||
long currentMicroAmps = BatteryRuntimeEstimator.toMicroamps(bm.getLongProperty(BatteryManager.BATTERY_PROPERTY_CURRENT_NOW));
|
||||
long chargeCounter = bm.getLongProperty(BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER);
|
||||
int voltageMv = status.getIntExtra(BatteryManager.EXTRA_VOLTAGE, 0);
|
||||
|
||||
@@ -606,36 +618,16 @@ public class HudMetrics {
|
||||
if (uw != null && uw != 0L) watts = (float) (Math.abs(uw) / 1_000_000.0);
|
||||
}
|
||||
|
||||
Double runtimeHours = !charging
|
||||
? batteryRuntimeEstimator.estimateHours(chargeCounter, Math.abs((double) currentMicroAmps))
|
||||
: null;
|
||||
String runtimeText;
|
||||
if (charging) {
|
||||
smoothedBatteryRuntimeHours = null;
|
||||
runtimeText = "LEFT CHG";
|
||||
} else if (currentMicroAmps <= 0L || chargeCounter <= 0L) {
|
||||
runtimeText = null;
|
||||
} else {
|
||||
double rawHours = (double) chargeCounter / (double) currentMicroAmps;
|
||||
if (!Double.isFinite(rawHours) || rawHours <= 0.0 || rawHours > MAX_RUNTIME_HOURS) {
|
||||
runtimeText = null;
|
||||
} else {
|
||||
double smoothed = smoothedBatteryRuntimeHours == null ? rawHours
|
||||
: (smoothedBatteryRuntimeHours * RUNTIME_SMOOTHING_OLD_WEIGHT)
|
||||
+ (rawHours * RUNTIME_SMOOTHING_NEW_WEIGHT);
|
||||
smoothedBatteryRuntimeHours = smoothed;
|
||||
runtimeText = "LEFT " + formatRuntimeHours(smoothed);
|
||||
}
|
||||
}
|
||||
if (st == BatteryManager.BATTERY_STATUS_FULL || (percent != null && percent >= 100)) runtimeText = "Full";
|
||||
else if (charging) runtimeText = "Charging";
|
||||
else runtimeText = BatteryRuntimeEstimator.formatDuration(runtimeHours);
|
||||
return new Battery(watts, charging, percent, tempC, runtimeText);
|
||||
}
|
||||
|
||||
private static String formatRuntimeHours(double hours) {
|
||||
int totalMinutes = Math.max(1, (int) Math.round(hours * 60.0));
|
||||
int wholeHours = totalMinutes / 60;
|
||||
int minutes = totalMinutes % 60;
|
||||
if (wholeHours > 0 && minutes > 0) return wholeHours + "h " + minutes + "m";
|
||||
if (wholeHours > 0) return wholeHours + "h";
|
||||
return minutes + "m";
|
||||
}
|
||||
|
||||
private static float currentRawToAmps(long raw) {
|
||||
if (raw == 0L || raw == Long.MIN_VALUE) return 0f;
|
||||
long a = Math.abs(raw);
|
||||
@@ -651,15 +643,10 @@ public class HudMetrics {
|
||||
return currentRawToAmps(raw);
|
||||
}
|
||||
|
||||
public Integer getCpuClockMhz() {
|
||||
int cores = Runtime.getRuntime().availableProcessors();
|
||||
long maxKhz = 0;
|
||||
for (int i = 0; i < cores; i++) {
|
||||
Long cur = readLongFromLine("/sys/devices/system/cpu/cpu" + i + "/cpufreq/scaling_cur_freq");
|
||||
if (cur != null && cur > maxKhz) maxKhz = cur;
|
||||
}
|
||||
if (maxKhz <= 0) return null;
|
||||
return (int) (maxKhz / 1000L);
|
||||
static Integer fastestCoreMhz(int[] perCoreMhz) {
|
||||
int max = 0;
|
||||
for (int mhz : perCoreMhz) max = Math.max(max, mhz);
|
||||
return max > 0 ? max : null;
|
||||
}
|
||||
|
||||
private List<String> gpuClockPathsCache = null;
|
||||
@@ -809,7 +796,8 @@ public class HudMetrics {
|
||||
if (mango != null) return mangoSnapshot(mango);
|
||||
Integer cpu = getCpuUsagePercent();
|
||||
Integer gpu = getGpuUsagePercent();
|
||||
Integer cpuClk = getCpuClockMhz();
|
||||
int[] perCoreClk = getPerCoreClockMhz();
|
||||
Integer cpuClk = fastestCoreMhz(perCoreClk);
|
||||
Integer gpuClk = getGpuClockMhz();
|
||||
Integer cpuTemp = getCpuTempC();
|
||||
Integer gpuTemp = getGpuTempC();
|
||||
@@ -829,7 +817,6 @@ public class HudMetrics {
|
||||
Battery battery = collectBattery();
|
||||
|
||||
int[] perCorePct = readPerCorePercent();
|
||||
int[] perCoreClk = getPerCoreClockMhz();
|
||||
long[] swap = getSwapBytes();
|
||||
long[] net = readNetRateBps();
|
||||
|
||||
@@ -848,26 +835,65 @@ public class HudMetrics {
|
||||
Battery android = collectBattery();
|
||||
MangoReadings.Battery bat = m.battery();
|
||||
Battery battery = bat == null ? android : new Battery(bat.getWatts(), bat.getCharging(),
|
||||
bat.getPercent() != null ? bat.getPercent() : android.percent, android.tempC, android.runtimeText);
|
||||
bat.getPercent() != null ? bat.getPercent() : android.percent, android.tempC, bat.getRuntimeText());
|
||||
long[] net = readNetRateBps();
|
||||
return new Snapshot(cpu != null ? cpu.getPercent() : null, m.gpuPercent(), getCpuClockMhz(), m.gpuClockMhz(),
|
||||
int[] perCoreClk = getPerCoreClockMhz();
|
||||
return new Snapshot(cpu != null ? cpu.getPercent() : null, m.gpuPercent(), fastestCoreMhz(perCoreClk), m.gpuClockMhz(),
|
||||
m.cpuTempC(), m.gpuTempC(), used, total, total > 0 ? used * 100f / total : 0f, m.vramBytes(), battery,
|
||||
cpu != null ? cpu.getPerCore() : new int[0], getPerCoreClockMhz(),
|
||||
cpu != null ? cpu.getPerCore() : new int[0], perCoreClk,
|
||||
mem != null && mem.getSwapTotalBytes() > 0 ? mem.getSwapUsedBytes() : null,
|
||||
mem != null && mem.getSwapTotalBytes() > 0 ? mem.getSwapTotalBytes() : null,
|
||||
net == null ? null : net[0], net == null ? null : net[1]);
|
||||
}
|
||||
|
||||
public int[] getPerCoreClockMhz() {
|
||||
private final java.util.Map<Integer, long[][]> lastTimeInState = new java.util.HashMap<>();
|
||||
|
||||
public synchronized int[] getPerCoreClockMhz() {
|
||||
int cores = Runtime.getRuntime().availableProcessors();
|
||||
int[] out = new int[Math.max(0, cores)];
|
||||
for (int i = 0; i < out.length; i++) {
|
||||
Long cur = readLongFromLine("/sys/devices/system/cpu/cpu" + i + "/cpufreq/scaling_cur_freq");
|
||||
out[i] = (cur != null && cur > 0) ? (int) (cur / 1000L) : 0;
|
||||
long[][] table = readTimeInState("/sys/devices/system/cpu/cpu" + i + "/cpufreq/stats/time_in_state");
|
||||
long khz = table == null ? -1L : averageKhz(lastTimeInState.put(i, table), table);
|
||||
if (khz <= 0L) {
|
||||
Long cur = readLongFromLine("/sys/devices/system/cpu/cpu" + i + "/cpufreq/scaling_cur_freq");
|
||||
khz = cur != null ? cur : 0L;
|
||||
}
|
||||
out[i] = khz > 0L ? (int) (khz / 1000L) : 0;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
static long averageKhz(long[][] before, long[][] after) {
|
||||
if (before == null || after == null || !java.util.Arrays.equals(before[0], after[0])) return -1L;
|
||||
long weighted = 0L, time = 0L;
|
||||
for (int i = 0; i < after[0].length; i++) {
|
||||
long dt = after[1][i] - before[1][i];
|
||||
if (dt <= 0L) continue;
|
||||
weighted += after[0][i] * dt;
|
||||
time += dt;
|
||||
}
|
||||
return time > 0L ? weighted / time : -1L;
|
||||
}
|
||||
|
||||
private static long[][] readTimeInState(String path) {
|
||||
List<long[]> rows = new ArrayList<>();
|
||||
try (BufferedReader r = new BufferedReader(new FileReader(path))) {
|
||||
String line;
|
||||
while ((line = r.readLine()) != null) {
|
||||
String[] parts = line.trim().split("\\s+");
|
||||
if (parts.length < 2) continue;
|
||||
try { rows.add(new long[] { Long.parseLong(parts[0]), Long.parseLong(parts[1]) }); }
|
||||
catch (NumberFormatException ignored) {}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
return null;
|
||||
}
|
||||
if (rows.isEmpty()) return null;
|
||||
long[][] table = new long[2][rows.size()];
|
||||
for (int i = 0; i < rows.size(); i++) { table[0][i] = rows.get(i)[0]; table[1][i] = rows.get(i)[1]; }
|
||||
return table;
|
||||
}
|
||||
|
||||
private long[] lastCoreTotal = null;
|
||||
private long[] lastCoreIdle = null;
|
||||
private static final int PER_CORE_STAT = 1, PER_CORE_ESTIMATE = 2;
|
||||
|
||||
@@ -2,13 +2,18 @@ package com.droiddeck.launcher.hud
|
||||
|
||||
import android.os.Environment
|
||||
import com.droiddeck.launcher.runtime.LinuxRuntime
|
||||
import com.droiddeck.launcher.session.BatteryRuntimeEstimator
|
||||
import java.io.File
|
||||
import kotlin.math.abs
|
||||
import kotlin.math.roundToInt
|
||||
|
||||
internal class MangoReadings(private val sessionDir: File, private val rootDir: File) {
|
||||
class Cpu(val percent: Int, val perCore: IntArray)
|
||||
class Memory(val usedBytes: Long, val totalBytes: Long, val swapUsedBytes: Long, val swapTotalBytes: Long)
|
||||
class Battery(val percent: Int?, val watts: Float, val charging: Boolean)
|
||||
class Battery(val percent: Int?, val watts: Float, val charging: Boolean, val runtimeText: String?)
|
||||
|
||||
private val batteryRuntimeEstimator = BatteryRuntimeEstimator()
|
||||
private var lastBatteryDischarging: Boolean? = null
|
||||
|
||||
private val cpuTimes = HashMap<String, LongArray>()
|
||||
private val cpuPercents = HashMap<String, Int>()
|
||||
@@ -106,32 +111,113 @@ internal class MangoReadings(private val sessionDir: File, private val rootDir:
|
||||
fun vramBytes(): Long? = fresh(File(rootDir, VRAM_FILE), VRAM_FRESH_MS)?.let(::readLong)?.takeIf { it > 0 }
|
||||
|
||||
fun battery(): Battery? {
|
||||
val dirs = File(sessionDir, "sys/power_supply").listFiles { f -> f.name.contains("BAT") }?.sortedBy { it.name }
|
||||
val dirs = File(sessionDir, "sys/power_supply").listFiles { f -> f.name.contains("BAT") }?.sortedBy { it.name }?.take(2)
|
||||
if (dirs.isNullOrEmpty()) return null
|
||||
var chargeNow = 0f
|
||||
var chargeFull = 0f
|
||||
var watts = 0f
|
||||
var charging = false
|
||||
|
||||
var weightedChargeNow = 0.0
|
||||
var weightedChargeFull = 0.0
|
||||
var allHaveWeightedCharge = true
|
||||
val perBatteryPercents = ArrayList<Int>()
|
||||
var runtimeChargeUah = 0.0
|
||||
var runtimeChargeComplete = true
|
||||
var aggregateCurrentUa = 0.0
|
||||
var currentComplete = true
|
||||
var watts = 0.0
|
||||
var anyDischarging = false
|
||||
var anyChargingStatus = false
|
||||
var allFull = true
|
||||
var suppliedRuntimeSeconds: Long? = null
|
||||
|
||||
for (dir in dirs) {
|
||||
val status = runCatching { File(dir, "status").readLines().firstOrNull() }.getOrNull()
|
||||
if (status == "Charging" || status == "Unknown" || status == "Full") charging = true
|
||||
val now = File(dir, "charge_now").takeIf { it.exists() } ?: File(dir, "energy_now")
|
||||
val full = File(dir, "charge_full").takeIf { it.exists() } ?: File(dir, "energy_full")
|
||||
if (now.exists()) {
|
||||
chargeNow += (readFloat(now) ?: 0f) / 1_000_000f
|
||||
chargeFull += (readFloat(full) ?: 0f) / 1_000_000f
|
||||
} else {
|
||||
chargeNow += (readFloat(File(dir, "capacity")) ?: 0f) / 100f
|
||||
chargeFull = dirs.size.toFloat()
|
||||
val isDischarging = status == "Discharging" || status == "Not charging"
|
||||
if (isDischarging) anyDischarging = true
|
||||
if (status == "Charging" || status == "Unknown") anyChargingStatus = true
|
||||
if (status != "Full") allFull = false
|
||||
|
||||
val chargeNowFile = File(dir, "charge_now")
|
||||
val chargeFullFile = File(dir, "charge_full")
|
||||
val energyNowFile = File(dir, "energy_now")
|
||||
val energyFullFile = File(dir, "energy_full")
|
||||
val voltageFile = File(dir, "voltage_now")
|
||||
val chargeNow = if (chargeNowFile.isFile) readFloat(chargeNowFile)?.toDouble() else null
|
||||
val chargeFull = if (chargeFullFile.isFile) readFloat(chargeFullFile)?.toDouble() else null
|
||||
val energyNow = if (energyNowFile.isFile) readFloat(energyNowFile)?.toDouble() else null
|
||||
val energyFull = if (energyFullFile.isFile) readFloat(energyFullFile)?.toDouble() else null
|
||||
val voltageUv = if (voltageFile.isFile) readFloat(voltageFile)?.toDouble() else null
|
||||
|
||||
val nowForPercent: Double? = when {
|
||||
chargeNow != null && chargeNow >= 0.0 -> chargeNow
|
||||
energyNow != null && voltageUv != null -> BatteryRuntimeEstimator.chargeMicroampHoursFromEnergy(energyNow, voltageUv)
|
||||
else -> null
|
||||
}
|
||||
if (!charging) {
|
||||
val power = File(dir, "power_now")
|
||||
watts += if (power.exists()) kotlin.math.abs(readFloat(power) ?: 0f) / 1_000_000f
|
||||
else kotlin.math.abs((readFloat(File(dir, "current_now")) ?: 0f) * (readFloat(File(dir, "voltage_now")) ?: 0f)) / 1e12f
|
||||
val fullForPercent: Double? = when {
|
||||
chargeFull != null && chargeFull > 0.0 -> chargeFull
|
||||
energyFull != null && voltageUv != null -> BatteryRuntimeEstimator.chargeMicroampHoursFromEnergy(energyFull, voltageUv)
|
||||
else -> null
|
||||
}
|
||||
if (nowForPercent != null && fullForPercent != null && fullForPercent > 0.0) {
|
||||
weightedChargeNow += nowForPercent
|
||||
weightedChargeFull += fullForPercent
|
||||
perBatteryPercents += (nowForPercent * 100.0 / fullForPercent).roundToInt().coerceIn(0, 100)
|
||||
} else {
|
||||
allHaveWeightedCharge = false
|
||||
readFloat(File(dir, "capacity"))?.roundToInt()?.coerceIn(0, 100)?.let { perBatteryPercents += it }
|
||||
}
|
||||
|
||||
when {
|
||||
chargeNow != null && chargeNow >= 0.0 -> runtimeChargeUah += chargeNow
|
||||
energyNow != null && voltageUv != null ->
|
||||
BatteryRuntimeEstimator.chargeMicroampHoursFromEnergy(energyNow, voltageUv)?.let { runtimeChargeUah += it }
|
||||
?: run { runtimeChargeComplete = false }
|
||||
else -> runtimeChargeComplete = false
|
||||
}
|
||||
|
||||
if (dirs.size == 1) {
|
||||
suppliedRuntimeSeconds = readLong(File(dir, "time_to_empty_avg"))?.takeIf { it > 0L }
|
||||
?: readLong(File(dir, "time_to_empty_now"))?.takeIf { it > 0L }
|
||||
?: suppliedRuntimeSeconds
|
||||
}
|
||||
|
||||
val currentFile = File(dir, "current_now")
|
||||
val powerFile = File(dir, "power_now")
|
||||
val currentNow = if (currentFile.isFile) readFloat(currentFile)?.toDouble() else null
|
||||
val currentForEta = when {
|
||||
currentNow != null -> abs(currentNow)
|
||||
powerFile.isFile && voltageUv != null -> readFloat(powerFile)?.toDouble()?.let {
|
||||
BatteryRuntimeEstimator.currentMicroampsFromPower(it, voltageUv)
|
||||
}
|
||||
else -> null
|
||||
}
|
||||
if (currentForEta == null) currentComplete = false else aggregateCurrentUa += currentForEta
|
||||
|
||||
if (isDischarging) {
|
||||
val power = if (powerFile.isFile) readFloat(powerFile)?.toDouble() else null
|
||||
if (power != null) watts += abs(power) / 1_000_000.0
|
||||
else if (currentNow != null && voltageUv != null) watts += abs(currentNow * voltageUv) / 1_000_000_000_000.0
|
||||
}
|
||||
}
|
||||
val percent = if (chargeFull > 0f) Math.round(chargeNow / chargeFull * 100f) else null
|
||||
return Battery(percent, if (charging) 0f else watts, charging)
|
||||
|
||||
val percent = when {
|
||||
allHaveWeightedCharge && weightedChargeFull > 0.0 -> (weightedChargeNow * 100.0 / weightedChargeFull).roundToInt().coerceIn(0, 100)
|
||||
perBatteryPercents.isNotEmpty() -> perBatteryPercents.average().roundToInt().coerceIn(0, 100)
|
||||
else -> null
|
||||
}
|
||||
if (lastBatteryDischarging != null && lastBatteryDischarging != anyDischarging) {
|
||||
batteryRuntimeEstimator.reset()
|
||||
}
|
||||
lastBatteryDischarging = anyDischarging
|
||||
val estimatedHours = if (anyDischarging && runtimeChargeComplete && currentComplete)
|
||||
batteryRuntimeEstimator.estimateHours(runtimeChargeUah, aggregateCurrentUa) else null
|
||||
val runtimeHours = suppliedRuntimeSeconds?.let { it / 3600.0 } ?: estimatedHours
|
||||
val charging = !anyDischarging && anyChargingStatus
|
||||
val runtimeText = when {
|
||||
anyDischarging -> BatteryRuntimeEstimator.formatDuration(runtimeHours)
|
||||
charging -> "Charging"
|
||||
allFull -> "Full"
|
||||
else -> null
|
||||
}
|
||||
return Battery(percent, if (anyDischarging) watts.toFloat() else 0f, charging, runtimeText)
|
||||
}
|
||||
|
||||
private fun fresh(file: File, maxAgeMs: Long = FEED_FRESH_MS): File? =
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
package com.droiddeck.launcher.input
|
||||
|
||||
import android.accessibilityservice.AccessibilityService
|
||||
import android.accessibilityservice.AccessibilityServiceInfo
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.PackageManager
|
||||
import android.graphics.Rect
|
||||
import android.hardware.display.DisplayManager
|
||||
import android.os.Build
|
||||
import android.os.Handler
|
||||
@@ -12,9 +10,9 @@ import android.os.HandlerThread
|
||||
import android.os.SystemClock
|
||||
import android.util.Log
|
||||
import android.view.Display
|
||||
import android.view.accessibility.AccessibilityEvent
|
||||
import android.view.accessibility.AccessibilityWindowInfo
|
||||
import android.view.inputmethod.InputMethodManager
|
||||
import com.droiddeck.shortcuts.Relay
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
|
||||
object BottomScreenGuests {
|
||||
@@ -45,7 +43,7 @@ object BottomScreenGuests {
|
||||
sdk >= 33 && DualScreen.yieldsBottom(model)
|
||||
}
|
||||
|
||||
class BottomScreenWatch(private val service: AccessibilityService) {
|
||||
class BottomScreenWatch(private val service: Context) {
|
||||
private class Arrival(val pkg: String, val at: Long)
|
||||
|
||||
private val thread = HandlerThread("bottom-screen").apply { start() }
|
||||
@@ -57,33 +55,22 @@ class BottomScreenWatch(private val service: AccessibilityService) {
|
||||
private var holders: Map<Int, String?> = emptyMap()
|
||||
private var ownWindows: Map<Int, Set<Int>> = emptyMap()
|
||||
private val ownShownAt = mutableMapOf<Int, Long>()
|
||||
private val check = Runnable { evaluate() }
|
||||
|
||||
fun start() {
|
||||
current = this
|
||||
service.serviceInfo = service.serviceInfo?.apply {
|
||||
eventTypes = eventTypes or AccessibilityEvent.TYPE_WINDOWS_CHANGED or AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED
|
||||
flags = flags or AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS
|
||||
}
|
||||
handler.post {
|
||||
homes = homePackages()
|
||||
keyboards = keyboardPackages()
|
||||
evaluate()
|
||||
}
|
||||
}
|
||||
|
||||
fun onEvent(event: AccessibilityEvent) {
|
||||
when (event.eventType) {
|
||||
AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED -> {
|
||||
val pkg = event.packageName?.toString() ?: return
|
||||
if (event.displayId == Display.DEFAULT_DISPLAY || pkg == own || pkg == SYSTEM_UI) return
|
||||
arrivals[event.displayId] = Arrival(pkg, event.eventTime)
|
||||
}
|
||||
AccessibilityEvent.TYPE_WINDOWS_CHANGED -> Unit
|
||||
else -> return
|
||||
}
|
||||
handler.removeCallbacks(check)
|
||||
handler.postDelayed(check, 150)
|
||||
fun onArrival(displayId: Int, pkg: String, at: Long) {
|
||||
if (displayId == Display.DEFAULT_DISPLAY || pkg == own || pkg == SYSTEM_UI) return
|
||||
arrivals[displayId] = Arrival(pkg, at)
|
||||
}
|
||||
|
||||
fun onWindows(all: Map<Int, List<Relay.Window>>) {
|
||||
handler.post { evaluate(all) }
|
||||
}
|
||||
|
||||
fun stop() {
|
||||
@@ -97,25 +84,22 @@ class BottomScreenWatch(private val service: AccessibilityService) {
|
||||
thread.quitSafely()
|
||||
}
|
||||
|
||||
private fun evaluate() {
|
||||
private fun evaluate(all: Map<Int, List<Relay.Window>>) {
|
||||
val seen = HashMap(arrivals)
|
||||
val all = runCatching { service.windowsOnAllDisplays }.getOrNull() ?: return
|
||||
val displays = service.getSystemService(DisplayManager::class.java) ?: return
|
||||
val taken = mutableMapOf<Int, String?>()
|
||||
val shown = mutableMapOf<Int, Set<Int>>()
|
||||
val now = SystemClock.uptimeMillis()
|
||||
for (i in 0 until all.size()) {
|
||||
val id = all.keyAt(i)
|
||||
for ((id, list) in all) {
|
||||
if (id == Display.DEFAULT_DISPLAY) continue
|
||||
val display = displays.getDisplay(id)?.takeIf(DualScreen::builtIn) ?: continue
|
||||
val windows = all.valueAt(i)
|
||||
val windows = list
|
||||
.filter { !BottomScreenGuests.ignorable(it.type) && cover(it, display) >= BottomScreenGuests.MIN_COVER }
|
||||
.sortedByDescending { it.layer }
|
||||
.map { it to packageOf(it) }
|
||||
val ours = windows.filter { it.second == own }.map { it.first.id }.toSet()
|
||||
val ours = windows.filter { it.pkg == own }.map { it.id }.toSet()
|
||||
if (!ownWindows[id].orEmpty().containsAll(ours)) ownShownAt[id] = now
|
||||
shown[id] = ours
|
||||
val topPkg = windows.firstNotNullOfOrNull { it.second?.takeUnless { pkg -> pkg == own } }
|
||||
val topPkg = windows.firstNotNullOfOrNull { it.pkg?.takeUnless { pkg -> pkg == own } }
|
||||
val arrival = seen[id]?.takeIf { BottomScreenGuests.current(it.at, ownShownAt[id]) }
|
||||
seen[id]?.takeIf { topPkg != null || arrival == null }?.let { arrivals.remove(id, it) }
|
||||
BottomScreenGuests.holder(topPkg, arrival?.pkg?.takeUnless { it in keyboards }, homes)?.let { taken[id] = it }
|
||||
@@ -127,15 +111,11 @@ class BottomScreenWatch(private val service: AccessibilityService) {
|
||||
DualScreen.setTaken(taken.keys)
|
||||
}
|
||||
|
||||
private fun cover(window: AccessibilityWindowInfo, display: Display): Float {
|
||||
val bounds = Rect().also(window::getBoundsInScreen)
|
||||
private fun cover(window: Relay.Window, display: Display): Float {
|
||||
val area = display.mode.physicalWidth.toFloat() * display.mode.physicalHeight
|
||||
return if (area <= 0f) 0f else bounds.width().toFloat() * bounds.height() / area
|
||||
return if (area <= 0f) 0f else window.bounds.width().toFloat() * window.bounds.height() / area
|
||||
}
|
||||
|
||||
private fun packageOf(window: AccessibilityWindowInfo): String? =
|
||||
runCatching { window.getRoot(0)?.packageName?.toString() }.getOrNull()
|
||||
|
||||
private fun homePackages(): Set<String> {
|
||||
val pm = service.packageManager
|
||||
return listOf(Intent.CATEGORY_HOME, Intent.CATEGORY_SECONDARY_HOME).flatMap { category ->
|
||||
@@ -154,6 +134,7 @@ class BottomScreenWatch(private val service: AccessibilityService) {
|
||||
|
||||
private companion object {
|
||||
@Volatile var current: BottomScreenWatch? = null
|
||||
|
||||
const val TAG = "BottomScreen"
|
||||
const val SYSTEM_UI = "com.android.systemui"
|
||||
}
|
||||
|
||||
@@ -82,6 +82,8 @@ public class FakeInputWriter {
|
||||
private static final int PAD_TYPE_OFFSET = IMU_OFFSET + 44;
|
||||
private static final int PAD_TYPE_SET = 0x80000000;
|
||||
private static final int LATENCY_OFFSET = IMU_OFFSET + 48;
|
||||
private static final int REMOTE_IMU_MODE_OFFSET = IMU_OFFSET + 52;
|
||||
private static final int REMOTE_IMU_PID_OFFSET = IMU_OFFSET + 56;
|
||||
public static final int LATENCY_CONTROLLER = 1;
|
||||
public static final int LATENCY_TOUCH = 2;
|
||||
private static volatile int latency = 0;
|
||||
@@ -231,6 +233,8 @@ public class FakeInputWriter {
|
||||
}
|
||||
data.putInt(IMU_OFFSET, 0);
|
||||
data.putInt(IMU_MODE_OFFSET, 0);
|
||||
data.putInt(REMOTE_IMU_MODE_OFFSET, 0);
|
||||
data.putInt(REMOTE_IMU_PID_OFFSET, 0);
|
||||
data.putLong(IMU_SEQ_OFFSET, 0L);
|
||||
for (int i = 0; i < 12; i++) {
|
||||
data.putShort(IMU_ACCEL_OFFSET + (i * 2), (short) 0);
|
||||
@@ -494,8 +498,11 @@ public class FakeInputWriter {
|
||||
if (ringSlot == null) return -1;
|
||||
synchronized (ringSlot) {
|
||||
ByteBuffer ring = ringSlot.data;
|
||||
int value = ring == null ? 0 : ring.getInt(IMU_MODE_OFFSET);
|
||||
return value < 0 ? value & 0xffff : -1;
|
||||
if (ring == null) return 0;
|
||||
int remote = ring.getInt(REMOTE_IMU_MODE_OFFSET);
|
||||
int pid = ring.getInt(REMOTE_IMU_PID_OFFSET);
|
||||
return ImuModes.combine(ring.getInt(IMU_MODE_OFFSET), remote,
|
||||
remote < 0 && pid > 0 && new File("/proc/" + pid).exists());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,158 @@
|
||||
package com.droiddeck.launcher.input
|
||||
|
||||
/** Where a USB mouse's input report keeps its buttons, motion and wheel, as its HID report descriptor lays them out. */
|
||||
class HidMouseReport(
|
||||
val reportId: Int,
|
||||
private val buttons: List<Field?>,
|
||||
private val x: Field,
|
||||
private val y: Field,
|
||||
private val wheel: Field?,
|
||||
) {
|
||||
class Field(private val bit: Int, private val size: Int, private val signed: Boolean) {
|
||||
fun read(report: ByteArray, length: Int, base: Int): Int {
|
||||
var value = 0
|
||||
for (i in 0 until minOf(size, 32)) {
|
||||
val at = base + bit + i
|
||||
if (at / 8 >= length) break
|
||||
if ((report[at / 8].toInt() shr (at % 8)) and 1 != 0) value = value or (1 shl i)
|
||||
}
|
||||
return if (signed && size in 1..31 && value and (1 shl (size - 1)) != 0) value - (1 shl size) else value
|
||||
}
|
||||
}
|
||||
|
||||
/** [buttons] has bit 0 set for the first button. */
|
||||
data class State(val buttons: Int, val dx: Int, val dy: Int, val wheel: Int)
|
||||
|
||||
/** Returns null for reports with another ID, such as a receiver's media keys. */
|
||||
fun decode(report: ByteArray, length: Int): State? {
|
||||
val base = if (reportId == 0) 0 else {
|
||||
if (length < 1 || (report[0].toInt() and 0xff) != reportId) return null
|
||||
8
|
||||
}
|
||||
var pressed = 0
|
||||
buttons.forEachIndexed { i, field -> if (field != null && field.read(report, length, base) != 0) pressed = pressed or (1 shl i) }
|
||||
return State(pressed, x.read(report, length, base), y.read(report, length, base), wheel?.read(report, length, base) ?: 0)
|
||||
}
|
||||
|
||||
companion object {
|
||||
/** The report every boot mouse sends after SET_PROTOCOL(boot): three buttons, then X and Y as signed bytes. */
|
||||
val BOOT = HidMouseReport(0, List(3) { Field(it, 1, false) }, Field(8, 8, true), Field(16, 8, true), null)
|
||||
|
||||
private const val BUTTON_PAGE = 0x09
|
||||
private const val MOUSE = 0x00010002
|
||||
private const val X = 0x00010030
|
||||
private const val Y = 0x00010031
|
||||
private const val WHEEL = 0x00010038
|
||||
private const val MAX_BUTTONS = 8
|
||||
private const val MAX_FIELD_BITS = 32
|
||||
private const val MAX_REPORT_COUNT = 4096
|
||||
|
||||
private class Global(var usagePage: Int = 0, var logicalMin: Int = 0, var reportSize: Int = 0,
|
||||
var reportCount: Int = 0, var reportId: Int = 0) {
|
||||
fun copy() = Global(usagePage, logicalMin, reportSize, reportCount, reportId)
|
||||
}
|
||||
|
||||
private class Placed(val reportId: Int, val field: Field)
|
||||
|
||||
/** Returns null if [descriptor] has no mouse collection with X and Y in one report. */
|
||||
fun parse(descriptor: ByteArray): HidMouseReport? {
|
||||
var global = Global()
|
||||
val pushed = ArrayDeque<Global>()
|
||||
val usages = mutableListOf<Int>()
|
||||
var usageMin = -1
|
||||
var usageMax = -1
|
||||
val offsets = HashMap<Int, Int>()
|
||||
var depth = 0
|
||||
var mouseDepth = -1
|
||||
var mouseDone = false
|
||||
val placed = HashMap<Int, Placed>()
|
||||
|
||||
fun usage(index: Int): Int = when {
|
||||
usages.isNotEmpty() -> usages.getOrElse(index) { usages.last() }
|
||||
usageMin >= 0 && usageMax >= usageMin -> minOf(usageMin + index, usageMax)
|
||||
else -> -1
|
||||
}
|
||||
|
||||
var i = 0
|
||||
while (i < descriptor.size) {
|
||||
val prefix = descriptor[i].toInt() and 0xff
|
||||
if (prefix == 0xfe) {
|
||||
if (i + 1 >= descriptor.size) break
|
||||
i += 3 + (descriptor[i + 1].toInt() and 0xff)
|
||||
continue
|
||||
}
|
||||
val size = intArrayOf(0, 1, 2, 4)[prefix and 3]
|
||||
if (i + 1 + size > descriptor.size) break
|
||||
var data = 0
|
||||
for (b in 0 until size) data = data or ((descriptor[i + 1 + b].toInt() and 0xff) shl (8 * b))
|
||||
val signedData = when (size) {
|
||||
1 -> data.toByte().toInt()
|
||||
2 -> data.toShort().toInt()
|
||||
else -> data
|
||||
}
|
||||
val tag = prefix shr 4
|
||||
when ((prefix shr 2) and 3) {
|
||||
0 -> {
|
||||
when (tag) {
|
||||
0x8 -> {
|
||||
if (global.reportSize !in 0..MAX_FIELD_BITS || global.reportCount !in 0..MAX_REPORT_COUNT) return null
|
||||
val start = offsets[global.reportId] ?: 0
|
||||
val isData = data and 1 == 0
|
||||
val isVariable = data and 2 != 0
|
||||
if (mouseDepth >= 0 && !mouseDone && isData && isVariable) {
|
||||
for (n in 0 until global.reportCount) {
|
||||
val u = usage(n)
|
||||
if (u < 0) break
|
||||
val field = Placed(global.reportId, Field(start + n * global.reportSize, global.reportSize, global.logicalMin < 0))
|
||||
val button = if (u ushr 16 == BUTTON_PAGE) u and 0xffff else 0
|
||||
when {
|
||||
u == X || u == Y || u == WHEEL -> placed.putIfAbsent(u, field)
|
||||
button in 1..MAX_BUTTONS -> placed.putIfAbsent(u, field)
|
||||
}
|
||||
}
|
||||
}
|
||||
offsets[global.reportId] = start + global.reportSize * global.reportCount
|
||||
}
|
||||
0xa -> {
|
||||
depth++
|
||||
if (mouseDepth < 0 && data == 1 && usage(0) == MOUSE) mouseDepth = depth
|
||||
}
|
||||
0xc -> {
|
||||
if (depth == mouseDepth) mouseDone = true
|
||||
depth--
|
||||
}
|
||||
}
|
||||
usages.clear()
|
||||
usageMin = -1
|
||||
usageMax = -1
|
||||
}
|
||||
1 -> when (tag) {
|
||||
0x0 -> global.usagePage = data
|
||||
0x1 -> global.logicalMin = signedData
|
||||
0x7 -> global.reportSize = data
|
||||
0x8 -> global.reportId = data
|
||||
0x9 -> global.reportCount = data
|
||||
0xa -> pushed.addLast(global.copy())
|
||||
0xb -> global = pushed.removeLastOrNull() ?: global
|
||||
}
|
||||
2 -> {
|
||||
val full = if (size == 4) data else (global.usagePage shl 16) or data
|
||||
when (tag) {
|
||||
0x0 -> usages += full
|
||||
0x1 -> usageMin = full
|
||||
0x2 -> usageMax = full
|
||||
}
|
||||
}
|
||||
}
|
||||
i += 1 + size
|
||||
}
|
||||
|
||||
val x = placed[X] ?: return null
|
||||
val y = placed[Y]?.takeIf { it.reportId == x.reportId } ?: return null
|
||||
val id = x.reportId
|
||||
val buttons = (1..MAX_BUTTONS).map { n -> placed[(BUTTON_PAGE shl 16) or n]?.takeIf { it.reportId == id }?.field }
|
||||
return HidMouseReport(id, buttons.dropLastWhile { it == null }, x.field, y.field,
|
||||
placed[WHEEL]?.takeIf { it.reportId == id }?.field)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package com.droiddeck.launcher.input;
|
||||
|
||||
final class ImuModes {
|
||||
private ImuModes() {}
|
||||
|
||||
// Steam and its Remote Play client each keep their own mode word, with the top bit set once written. Motion is
|
||||
// read while either process wants it, and a word that has not been set leaves the choice to the other one.
|
||||
// -1 means neither has set a mode yet.
|
||||
static int combine(int steam, int remote, boolean remoteRunning) {
|
||||
boolean remoteSet = remote < 0 && remoteRunning;
|
||||
if (steam >= 0 && !remoteSet) return -1;
|
||||
return ((steam < 0 ? steam : 0) | (remoteSet ? remote : 0)) & 0xffff;
|
||||
}
|
||||
}
|
||||
@@ -3,11 +3,16 @@ package com.droiddeck.launcher.input
|
||||
object InputSpace {
|
||||
const val WIDTH = 1920
|
||||
const val HEIGHT = 1080
|
||||
const val FIXED_ONE = 256
|
||||
|
||||
fun x(position: Float, viewWidth: Int): Int = scale(position, viewWidth, WIDTH)
|
||||
|
||||
fun y(position: Float, viewHeight: Int): Int = scale(position, viewHeight, HEIGHT)
|
||||
|
||||
fun fixedX(position: Float, viewWidth: Int): Int = scale(position, viewWidth, WIDTH * FIXED_ONE)
|
||||
|
||||
fun fixedY(position: Float, viewHeight: Int): Int = scale(position, viewHeight, HEIGHT * FIXED_ONE)
|
||||
|
||||
private fun scale(position: Float, extent: Int, size: Int): Int =
|
||||
if (extent <= 0) 0 else (position / extent * size).toInt().coerceIn(0, size - 1)
|
||||
}
|
||||
@@ -57,6 +57,16 @@ class MouseBackInput(private val sendRight: (Boolean) -> Unit, private val mouse
|
||||
!device.supportsSource(InputDevice.SOURCE_TOUCHSCREEN)
|
||||
}
|
||||
|
||||
/** A controller's own mouse interface (8BitDo Ultimate Mobile) is not a mouse the user right-clicks with. */
|
||||
fun externalMouse(devices: List<InputDevice?>): InputDevice? {
|
||||
val controllers = devices.filterNotNull().filter { PadBridge.isFromController(it) }
|
||||
return devices.filterNotNull().firstOrNull { mouse ->
|
||||
isExternalMouse(mouse) && controllers.none {
|
||||
it.vendorId != 0 && it.vendorId == mouse.vendorId && it.productId == mouse.productId
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private val VIRTUAL_NAME = Regex("\\bvirtual\\b", RegexOption.IGNORE_CASE)
|
||||
|
||||
fun declaresVirtual(name: String?): Boolean = name != null && VIRTUAL_NAME.containsMatchIn(name)
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
package com.droiddeck.launcher.input
|
||||
|
||||
import kotlin.math.abs
|
||||
|
||||
/**
|
||||
* Holding the middle button still opens the session menu. While the session reads the mouse over USB, Android has
|
||||
* no cursor, so this is how a mouse reaches the menu and, through it, the system again.
|
||||
*/
|
||||
class MouseMenuHold(
|
||||
private val schedule: (Runnable, Long) -> Unit,
|
||||
private val cancel: (Runnable) -> Unit,
|
||||
private val onMenu: () -> Unit,
|
||||
) {
|
||||
private var holding = false
|
||||
private var travel = 0
|
||||
private val fire = Runnable {
|
||||
if (!holding) return@Runnable
|
||||
holding = false
|
||||
onMenu()
|
||||
}
|
||||
|
||||
fun onButton(index: Int, down: Boolean) {
|
||||
if (index != MIDDLE) return
|
||||
cancel(fire)
|
||||
holding = down
|
||||
travel = 0
|
||||
if (down) schedule(fire, HOLD_MS)
|
||||
}
|
||||
|
||||
fun onMove(dx: Int, dy: Int) {
|
||||
if (!holding) return
|
||||
travel += abs(dx) + abs(dy)
|
||||
if (travel > SLOP) reset()
|
||||
}
|
||||
|
||||
fun reset() {
|
||||
holding = false
|
||||
cancel(fire)
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val MIDDLE = 2
|
||||
const val HOLD_MS = 2000L
|
||||
const val SLOP = 48
|
||||
}
|
||||
}
|
||||
@@ -56,6 +56,7 @@ public final class PadBridge {
|
||||
private final FakeInputWriter[] playerWriters = new FakeInputWriter[SLOTS];
|
||||
private final PadState[] playerStates = new PadState[SLOTS];
|
||||
private final float[][] rawSticks = new float[SLOTS][4];
|
||||
private final boolean[][] keyTriggers = new boolean[SLOTS][2];
|
||||
private final int[] retainedSticks = new int[SLOTS];
|
||||
private final PadState effectiveState = new PadState();
|
||||
private final PadState homeGuideReport = new PadState();
|
||||
@@ -289,7 +290,10 @@ public final class PadBridge {
|
||||
}
|
||||
|
||||
public static boolean isControllerKeyEvent(KeyEvent event) {
|
||||
InputDevice device = event.getDevice();
|
||||
return isControllerKeyEvent(event, event.getDevice());
|
||||
}
|
||||
|
||||
static boolean isControllerKeyEvent(KeyEvent event, InputDevice device) {
|
||||
if (device == null || device.isVirtual() || isSystemVirtualInputName(device.getName())) return false;
|
||||
if (KeyEvent.isGamepadButton(event.getKeyCode())) {
|
||||
return device.supportsSource(InputDevice.SOURCE_GAMEPAD)
|
||||
@@ -314,7 +318,10 @@ public final class PadBridge {
|
||||
}
|
||||
|
||||
public static boolean isControllerMotionEvent(MotionEvent event) {
|
||||
InputDevice device = event.getDevice();
|
||||
return isControllerMotionEvent(event, event.getDevice());
|
||||
}
|
||||
|
||||
static boolean isControllerMotionEvent(MotionEvent event, InputDevice device) {
|
||||
return event.isFromSource(InputDevice.SOURCE_JOYSTICK) && device != null && !device.isVirtual()
|
||||
&& !isSystemVirtualInputName(device.getName())
|
||||
&& (device.supportsSource(InputDevice.SOURCE_GAMEPAD)
|
||||
@@ -375,10 +382,11 @@ public final class PadBridge {
|
||||
}
|
||||
|
||||
public synchronized boolean onKeyEvent(KeyEvent event) {
|
||||
if (!isControllerKeyEvent(event) || excluded.test(event.getDeviceId())) return false;
|
||||
int slot = slotFor(event.getDevice());
|
||||
InputDevice device = event.getDevice();
|
||||
if (!isControllerKeyEvent(event, device) || excluded.test(event.getDeviceId())) return false;
|
||||
int slot = slotFor(device);
|
||||
if (slot < 0) return false;
|
||||
int side = JoyCon.side(event.getDevice());
|
||||
int side = JoyCon.side(device);
|
||||
if (side >= 0 && partners[slot] != NO_CONTROLLER && JoyCon.isRail(side, event.getScanCode())) return true;
|
||||
long timing = InputTiming.begin();
|
||||
PadState pad = stateFor(slot);
|
||||
@@ -400,18 +408,18 @@ public final class PadBridge {
|
||||
case KeyEvent.KEYCODE_HOME:
|
||||
case KeyEvent.KEYCODE_MOVE_HOME: pad.press(PadState.GUIDE, pressed); break;
|
||||
case KeyEvent.KEYCODE_BUTTON_Z:
|
||||
if (isPrimary(event)) DeckControls.INSTANCE.setGrip(isNovaController(event.getDevice()) ? DeckControls.R4 : DeckControls.L4, pressed);
|
||||
if (isPrimary(event)) DeckControls.INSTANCE.setGrip(isNovaController(device) ? DeckControls.R4 : DeckControls.L4, pressed);
|
||||
break;
|
||||
case KeyEvent.KEYCODE_BUTTON_C:
|
||||
if (isPrimary(event)) DeckControls.INSTANCE.setGrip(isNovaController(event.getDevice()) ? DeckControls.L4 : DeckControls.R4, pressed);
|
||||
if (isPrimary(event)) DeckControls.INSTANCE.setGrip(isNovaController(device) ? DeckControls.L4 : DeckControls.R4, pressed);
|
||||
break;
|
||||
case KeyEvent.KEYCODE_BUTTON_L2:
|
||||
pad.leftTrigger = keyTrigger(pad.leftTrigger, pressed, event.getRepeatCount(),
|
||||
analogTrigger(event.getDevice(), MotionEvent.AXIS_LTRIGGER, MotionEvent.AXIS_BRAKE));
|
||||
analogTrigger(device, MotionEvent.AXIS_LTRIGGER, MotionEvent.AXIS_BRAKE), keyTriggers[slot], 0);
|
||||
break;
|
||||
case KeyEvent.KEYCODE_BUTTON_R2:
|
||||
pad.rightTrigger = keyTrigger(pad.rightTrigger, pressed, event.getRepeatCount(),
|
||||
analogTrigger(event.getDevice(), MotionEvent.AXIS_RTRIGGER, MotionEvent.AXIS_GAS));
|
||||
analogTrigger(device, MotionEvent.AXIS_RTRIGGER, MotionEvent.AXIS_GAS), keyTriggers[slot], 1);
|
||||
break;
|
||||
case KeyEvent.KEYCODE_DPAD_UP: pad.up = pressed; break;
|
||||
case KeyEvent.KEYCODE_DPAD_RIGHT: pad.right = pressed; break;
|
||||
@@ -419,7 +427,7 @@ public final class PadBridge {
|
||||
case KeyEvent.KEYCODE_DPAD_LEFT: pad.left = pressed; break;
|
||||
default: return false;
|
||||
}
|
||||
noteDevice(event.getDevice(), slot);
|
||||
noteDevice(device, slot);
|
||||
if (pressed && event.getRepeatCount() == 0 && !event.isCanceled()) noteChordInput(slot);
|
||||
if (pressed) notePlayerInput();
|
||||
statButtons++;
|
||||
@@ -471,6 +479,7 @@ public final class PadBridge {
|
||||
stateFor(slot).clear();
|
||||
retainedSticks[slot] = 0;
|
||||
Arrays.fill(rawSticks[slot], 0f);
|
||||
Arrays.fill(keyTriggers[slot], false);
|
||||
}
|
||||
|
||||
private void mutateState(java.util.function.Consumer<PadState> mutation) {
|
||||
@@ -489,16 +498,16 @@ public final class PadBridge {
|
||||
}
|
||||
|
||||
public synchronized boolean onMotionEvent(MotionEvent event) {
|
||||
if (!isControllerMotionEvent(event) || excluded.test(event.getDeviceId())) return false;
|
||||
InputDevice device = event.getDevice();
|
||||
if (!isControllerMotionEvent(event, device) || excluded.test(event.getDeviceId())) return false;
|
||||
if (event.getAction() != MotionEvent.ACTION_MOVE) return false;
|
||||
int slot = slotFor(event.getDevice());
|
||||
int slot = slotFor(device);
|
||||
if (slot < 0) return false;
|
||||
long timing = InputTiming.begin();
|
||||
PadState pad = stateFor(slot);
|
||||
noteDevice(event.getDevice(), slot);
|
||||
noteDevice(device, slot);
|
||||
statAxes++;
|
||||
scheduleStats();
|
||||
InputDevice device = event.getDevice();
|
||||
int side = JoyCon.side(device);
|
||||
if (side >= 0) {
|
||||
int[] stick = JoyCon.stickAxes(side, device, event.getSource());
|
||||
@@ -515,7 +524,7 @@ public final class PadBridge {
|
||||
}
|
||||
float lx = event.getAxisValue(MotionEvent.AXIS_X);
|
||||
float ly = event.getAxisValue(MotionEvent.AXIS_Y);
|
||||
boolean wired = wiredXboxLayout(event);
|
||||
boolean wired = wiredXboxLayout(device, event.getSource());
|
||||
float rx = event.getAxisValue(wired ? MotionEvent.AXIS_RX : MotionEvent.AXIS_Z);
|
||||
float ry = event.getAxisValue(wired ? MotionEvent.AXIS_RY : MotionEvent.AXIS_RZ);
|
||||
retainStick(slot, JoyCon.LEFT, lx, ly);
|
||||
@@ -525,11 +534,11 @@ public final class PadBridge {
|
||||
float lt = 0f;
|
||||
float rt = 0f;
|
||||
if (wired || hasAxis(device, source, MotionEvent.AXIS_LTRIGGER, MotionEvent.AXIS_BRAKE)) {
|
||||
lt = leftTrigger(event, wired);
|
||||
lt = axisTrigger(leftTrigger(event, wired), keyTriggers[slot], 0);
|
||||
pad.leftTrigger = lt;
|
||||
}
|
||||
if (wired || hasAxis(device, source, MotionEvent.AXIS_RTRIGGER, MotionEvent.AXIS_GAS)) {
|
||||
rt = rightTrigger(event, wired);
|
||||
rt = axisTrigger(rightTrigger(event, wired), keyTriggers[slot], 1);
|
||||
pad.rightTrigger = rt;
|
||||
}
|
||||
if (hasAxis(device, source, MotionEvent.AXIS_HAT_X)) {
|
||||
@@ -553,9 +562,27 @@ public final class PadBridge {
|
||||
return true;
|
||||
}
|
||||
|
||||
static float keyTrigger(float current, boolean pressed, int repeatCount, boolean analog) {
|
||||
if (analog || repeatCount > 0) return current;
|
||||
return pressed ? 1f : 0f;
|
||||
static float keyTrigger(float current, boolean pressed, int repeatCount, boolean analog, boolean[] held, int side) {
|
||||
if (repeatCount > 0) return current;
|
||||
if (!analog) {
|
||||
held[side] = pressed;
|
||||
return pressed ? 1f : 0f;
|
||||
}
|
||||
if (pressed) {
|
||||
if (current != 0f) return current;
|
||||
held[side] = true;
|
||||
return 1f;
|
||||
}
|
||||
if (!held[side]) return current;
|
||||
held[side] = false;
|
||||
return 0f;
|
||||
}
|
||||
|
||||
static float axisTrigger(float value, boolean[] held, int side) {
|
||||
if (!held[side]) return value;
|
||||
if (value == 0f) return 1f;
|
||||
held[side] = false;
|
||||
return value;
|
||||
}
|
||||
|
||||
static boolean analogTrigger(InputDevice device, int... axes) {
|
||||
@@ -987,7 +1014,7 @@ public final class PadBridge {
|
||||
}
|
||||
|
||||
private boolean isPrimary(KeyEvent event) {
|
||||
int id = event.getDevice().getId();
|
||||
int id = event.getDeviceId();
|
||||
int first = firstPlayerSlot();
|
||||
return owners[first] == id || partners[first] == id;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
package com.droiddeck.launcher.input
|
||||
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
|
||||
object PenRouter {
|
||||
enum class Route { BLOCKED, PEN, RELATIVE, TOUCH }
|
||||
|
||||
fun decide(uiBlocking: Boolean, mode: String, glasses: Boolean, programLock: Boolean): Route = when {
|
||||
uiBlocking -> Route.BLOCKED
|
||||
mode == SessionPrefs.PEN_TOUCH -> Route.TOUCH
|
||||
glasses || programLock -> Route.RELATIVE
|
||||
else -> Route.PEN
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,247 @@
|
||||
package com.droiddeck.launcher.input
|
||||
|
||||
import android.graphics.RectF
|
||||
import android.os.Build
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.SystemClock
|
||||
import android.view.InputDevice
|
||||
import android.view.KeyEvent
|
||||
import android.view.MotionEvent
|
||||
import com.droiddeck.launcher.session.SessionPrefs
|
||||
|
||||
class PenStream(private val sink: Sink) {
|
||||
fun interface Sink {
|
||||
fun sample(flags: Int, x: Int, y: Int)
|
||||
}
|
||||
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private val exitLater = Runnable { if (exitPending) leave() }
|
||||
private val hoverWatchdog = Runnable { checkHover() }
|
||||
private var watching = false
|
||||
private var contact = false
|
||||
private var barrel = 0
|
||||
private var keyDown = false
|
||||
private var keyDevice = Int.MIN_VALUE
|
||||
private var keyCode = 0
|
||||
private var exitPending = false
|
||||
private var exitTime = 0L
|
||||
private var deviceId = Int.MIN_VALUE
|
||||
private var x = 0
|
||||
private var y = 0
|
||||
private var sampleTime = 0L
|
||||
|
||||
var sideButton = SessionPrefs.PEN_BUTTON_RIGHT
|
||||
|
||||
var inProximity = false
|
||||
private set
|
||||
|
||||
fun onMotion(event: MotionEvent, pointer: Int, area: RectF, width: Int, height: Int): Boolean {
|
||||
val action = event.actionMasked
|
||||
val time = event.eventTime
|
||||
val own = isPenAction(event, pointer)
|
||||
expire(time)
|
||||
when (action) {
|
||||
MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE -> {
|
||||
continueAt(time)
|
||||
contact = false
|
||||
enter(event)
|
||||
samples(event, pointer, area, width, height)
|
||||
}
|
||||
MotionEvent.ACTION_HOVER_EXIT -> if (inProximity && !exitPending && !contact) pendExit(time)
|
||||
MotionEvent.ACTION_BUTTON_PRESS, MotionEvent.ACTION_BUTTON_RELEASE -> {
|
||||
continueAt(time)
|
||||
if (!inProximity) return true
|
||||
barrel = event.buttonState
|
||||
samples(event, pointer, area, width, height)
|
||||
}
|
||||
MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN -> if (own) {
|
||||
continueAt(time)
|
||||
enter(event)
|
||||
contact = true
|
||||
samples(event, pointer, area, width, height)
|
||||
} else if (contact) samples(event, pointer, area, width, height)
|
||||
MotionEvent.ACTION_MOVE -> if (contact) {
|
||||
barrel = event.buttonState
|
||||
samples(event, pointer, area, width, height)
|
||||
}
|
||||
MotionEvent.ACTION_UP, MotionEvent.ACTION_POINTER_UP -> if (!own) {
|
||||
if (contact) samples(event, pointer, area, width, height)
|
||||
} else if (contact) {
|
||||
if (event.flags and MotionEvent.FLAG_CANCELED != 0) cancel()
|
||||
else {
|
||||
barrel = event.buttonState
|
||||
samples(event, pointer, area, width, height, lift = true)
|
||||
pendExit(time)
|
||||
}
|
||||
}
|
||||
MotionEvent.ACTION_CANCEL -> cancel()
|
||||
else -> return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun onKey(event: KeyEvent): Boolean {
|
||||
expire(event.eventTime)
|
||||
val down = event.action == KeyEvent.ACTION_DOWN
|
||||
val repeat = event.repeatCount > 0
|
||||
if (exitPending && !repeat) leave()
|
||||
if (!inProximity || exitPending) {
|
||||
if (!repeat && event.deviceId == keyDevice && event.keyCode == keyCode) keyDown = down
|
||||
return true
|
||||
}
|
||||
if (down == keyDown) return true
|
||||
val before = state()
|
||||
keyDown = down
|
||||
if (down) {
|
||||
keyDevice = event.deviceId
|
||||
keyCode = event.keyCode
|
||||
}
|
||||
if (state() == before) return true
|
||||
emit(state())
|
||||
return true
|
||||
}
|
||||
|
||||
fun cancel(releaseKey: Boolean = false) {
|
||||
if (releaseKey) keyDown = false
|
||||
leave()
|
||||
}
|
||||
|
||||
fun holdsKey(event: KeyEvent): Boolean = keyDown && event.deviceId == keyDevice && event.keyCode == keyCode
|
||||
|
||||
fun deviceRemoved(deviceId: Int) {
|
||||
if (deviceId == this.deviceId) cancel()
|
||||
if (!keyDown || deviceId != keyDevice) return
|
||||
val before = state()
|
||||
keyDown = false
|
||||
if (inProximity && state() != before) emit(state())
|
||||
}
|
||||
|
||||
private fun enter(event: MotionEvent) {
|
||||
barrel = event.buttonState
|
||||
if (inProximity) return
|
||||
inProximity = true
|
||||
deviceId = event.deviceId
|
||||
}
|
||||
|
||||
private fun continueAt(time: Long) {
|
||||
if (!exitPending) return
|
||||
if (time - exitTime > EXIT_GRACE_MS) { leave(); return }
|
||||
exitPending = false
|
||||
handler.removeCallbacks(exitLater)
|
||||
}
|
||||
|
||||
private fun pendExit(time: Long) {
|
||||
exitPending = true
|
||||
exitTime = time
|
||||
handler.removeCallbacks(exitLater)
|
||||
handler.postDelayed(exitLater, EXIT_GRACE_MS)
|
||||
}
|
||||
|
||||
private fun expire(time: Long) {
|
||||
if (inProximity && !contact && time - sampleTime >= HOVER_TIMEOUT_MS) leave()
|
||||
}
|
||||
|
||||
private fun watchHover(delay: Long = HOVER_TIMEOUT_MS) {
|
||||
if (watching || contact) return
|
||||
watching = true
|
||||
handler.postDelayed(hoverWatchdog, delay)
|
||||
}
|
||||
|
||||
private fun checkHover() {
|
||||
watching = false
|
||||
if (!inProximity || contact || exitPending) return
|
||||
val silent = SystemClock.uptimeMillis() - sampleTime
|
||||
if (silent >= HOVER_TIMEOUT_MS) leave() else watchHover(HOVER_TIMEOUT_MS - silent)
|
||||
}
|
||||
|
||||
private fun leave() {
|
||||
if (!inProximity) return
|
||||
emit(0)
|
||||
handler.removeCallbacks(exitLater)
|
||||
handler.removeCallbacks(hoverWatchdog)
|
||||
watching = false
|
||||
inProximity = false
|
||||
contact = false
|
||||
exitPending = false
|
||||
barrel = 0
|
||||
}
|
||||
|
||||
private fun samples(event: MotionEvent, pointer: Int, area: RectF, width: Int, height: Int, lift: Boolean = false) {
|
||||
for (h in 0 until event.historySize) sample(event, pointer, h, area, width, height)
|
||||
if (lift) contact = false
|
||||
sample(event, pointer, -1, area, width, height)
|
||||
}
|
||||
|
||||
private fun sample(event: MotionEvent, pointer: Int, h: Int, area: RectF, width: Int, height: Int) {
|
||||
x = InputSpace.fixedX(event.axis(MotionEvent.AXIS_X, pointer, h).coerceIn(area.left, area.right), width)
|
||||
y = InputSpace.fixedY(event.axis(MotionEvent.AXIS_Y, pointer, h).coerceIn(area.top, area.bottom), height)
|
||||
sampleTime = if (h < 0) event.eventTime else event.getHistoricalEventTime(h)
|
||||
emit(state())
|
||||
watchHover()
|
||||
}
|
||||
|
||||
private fun emit(flags: Int) = sink.sample(flags, x, y)
|
||||
|
||||
private fun state(): Int =
|
||||
PEN_IN or (if (contact) PEN_TIP else 0) or buttonFlags(keyDown || barrel and MotionEvent.BUTTON_STYLUS_PRIMARY != 0,
|
||||
barrel and MotionEvent.BUTTON_STYLUS_SECONDARY != 0, sideButton)
|
||||
|
||||
private fun MotionEvent.axis(axis: Int, pointer: Int, h: Int): Float =
|
||||
if (h < 0) getAxisValue(axis, pointer) else getHistoricalAxisValue(axis, pointer, h)
|
||||
|
||||
companion object {
|
||||
const val PEN_IN = 1 shl 0
|
||||
const val PEN_TIP = 1 shl 1
|
||||
const val PEN_RIGHT = 1 shl 2
|
||||
const val PEN_MIDDLE = 1 shl 3
|
||||
const val HOVER_TIMEOUT_MS = 2_000L
|
||||
const val EXIT_GRACE_MS = 50L
|
||||
|
||||
private val PEN_NAME = Regex("\\b(pen|stylus)", RegexOption.IGNORE_CASE)
|
||||
|
||||
fun isPen(event: MotionEvent, index: Int): Boolean = when (event.getToolType(index)) {
|
||||
MotionEvent.TOOL_TYPE_STYLUS, MotionEvent.TOOL_TYPE_ERASER -> true
|
||||
MotionEvent.TOOL_TYPE_UNKNOWN -> event.isFromSource(InputDevice.SOURCE_STYLUS)
|
||||
else -> false
|
||||
}
|
||||
|
||||
fun penConnected(): Boolean =
|
||||
InputDevice.getDeviceIds().any { id -> InputDevice.getDevice(id)?.let { isPenDevice(it.sources) } == true }
|
||||
|
||||
// Before Android 14 a touchscreen that declares ABS_MT_TOOL_TYPE reports SOURCE_STYLUS without any pen.
|
||||
fun isPenDevice(sources: Int, sdk: Int = Build.VERSION.SDK_INT): Boolean =
|
||||
sources and InputDevice.SOURCE_STYLUS == InputDevice.SOURCE_STYLUS &&
|
||||
(sources and InputDevice.SOURCE_TOUCHSCREEN != InputDevice.SOURCE_TOUCHSCREEN || sdk >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
|
||||
|
||||
fun penIndex(event: MotionEvent): Int {
|
||||
for (index in 0 until event.pointerCount) if (isPen(event, index)) return index
|
||||
return -1
|
||||
}
|
||||
|
||||
fun isPenAction(event: MotionEvent, index: Int): Boolean = when (event.actionMasked) {
|
||||
MotionEvent.ACTION_DOWN, MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> true
|
||||
MotionEvent.ACTION_POINTER_DOWN, MotionEvent.ACTION_POINTER_UP -> event.actionIndex == index
|
||||
else -> false
|
||||
}
|
||||
|
||||
fun isPenKey(event: KeyEvent): Boolean {
|
||||
val device = event.device ?: return false
|
||||
return isPenKeyboard(device.name, device.sources, Build.VERSION.SDK_INT < Build.VERSION_CODES.Q || device.isExternal,
|
||||
device.keyboardType == InputDevice.KEYBOARD_TYPE_ALPHABETIC)
|
||||
}
|
||||
|
||||
fun isPenKeyboard(name: String?, sources: Int, external: Boolean, alphabetic: Boolean): Boolean =
|
||||
external && !alphabetic && sources == InputDevice.SOURCE_KEYBOARD && name != null && PEN_NAME.containsMatchIn(name)
|
||||
|
||||
fun buttonFlags(primary: Boolean, secondary: Boolean, sideButton: String): Int {
|
||||
val first = when (sideButton) {
|
||||
SessionPrefs.PEN_BUTTON_RIGHT -> PEN_RIGHT
|
||||
SessionPrefs.PEN_BUTTON_MIDDLE -> PEN_MIDDLE
|
||||
else -> 0
|
||||
}
|
||||
val second = if (sideButton == SessionPrefs.PEN_BUTTON_RIGHT) PEN_MIDDLE else PEN_RIGHT
|
||||
return (if (primary) first else 0) or (if (secondary) second else 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -23,13 +23,20 @@ internal fun MotionEvent.pointerSubset(pointerIdBits: Int): MotionEvent? {
|
||||
}
|
||||
val properties = Array(indices.size) { MotionEvent.PointerProperties() }
|
||||
val coordinates = Array(indices.size) { MotionEvent.PointerCoords() }
|
||||
indices.forEachIndexed { target, index ->
|
||||
getPointerProperties(index, properties[target])
|
||||
getPointerCoords(index, coordinates[target])
|
||||
indices.forEachIndexed { target, index -> getPointerProperties(index, properties[target]) }
|
||||
fun sample(position: Int): Array<MotionEvent.PointerCoords> {
|
||||
indices.forEachIndexed { target, index ->
|
||||
if (position < historySize) getHistoricalPointerCoords(index, position, coordinates[target])
|
||||
else getPointerCoords(index, coordinates[target])
|
||||
}
|
||||
return coordinates
|
||||
}
|
||||
return MotionEvent.obtain(
|
||||
downTime, eventTime, splitAction, indices.size, properties, coordinates,
|
||||
fun time(position: Int) = if (position < historySize) getHistoricalEventTime(position) else eventTime
|
||||
val split = MotionEvent.obtain(
|
||||
downTime, time(0), splitAction, indices.size, properties, sample(0),
|
||||
metaState, buttonState, xPrecision, yPrecision,
|
||||
deviceId, edgeFlags, source, flags,
|
||||
)
|
||||
for (position in 1..historySize) split.addBatch(time(position), sample(position), metaState)
|
||||
return split
|
||||
}
|
||||
+64
-21
@@ -1,14 +1,17 @@
|
||||
package com.droiddeck.launcher.input
|
||||
|
||||
import android.accessibilityservice.AccessibilityService
|
||||
import android.app.Service
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.hardware.input.InputManager
|
||||
import android.os.Binder
|
||||
import android.os.Handler
|
||||
import android.os.IBinder
|
||||
import android.os.Looper
|
||||
import android.os.Parcel
|
||||
import android.view.KeyEvent
|
||||
import android.view.accessibility.AccessibilityEvent
|
||||
import com.droiddeck.launcher.HomeApp
|
||||
import com.droiddeck.shortcuts.Relay
|
||||
|
||||
object HomeButtonShortcuts {
|
||||
private var owner: Any? = null
|
||||
@@ -101,38 +104,78 @@ object SystemKeyCapture {
|
||||
}
|
||||
}
|
||||
|
||||
class HomeButtonService : AccessibilityService(), InputManager.InputDeviceListener {
|
||||
class ShortcutsRelay : Service(), InputManager.InputDeviceListener {
|
||||
private val main = Handler(Looper.getMainLooper())
|
||||
private val trusted = java.util.concurrent.ConcurrentHashMap.newKeySet<Int>()
|
||||
private var bottomScreen: BottomScreenWatch? = null
|
||||
|
||||
override fun onServiceConnected() {
|
||||
getSystemService(InputManager::class.java).registerInputDeviceListener(this, Handler(Looper.getMainLooper()))
|
||||
if (bottomScreen == null && BottomScreenGuests.supported()) bottomScreen = BottomScreenWatch(this).also { it.start() }
|
||||
private val binder = object : Binder() {
|
||||
override fun onTransact(code: Int, data: Parcel, reply: Parcel?, flags: Int): Boolean {
|
||||
if (code !in Relay.CONFIG..Relay.WINDOWS) return super.onTransact(code, data, reply, flags)
|
||||
data.enforceInterface(Relay.DESCRIPTOR)
|
||||
if (!trusts(Binder.getCallingUid())) return false
|
||||
when (code) {
|
||||
Relay.CONFIG -> reply?.writeInt(if (bottomScreen != null) Relay.WANTS_WINDOWS else 0)
|
||||
Relay.KEY -> reply?.writeInt(if (onMain(KeyEvent.CREATOR.createFromParcel(data))) 1 else 0)
|
||||
Relay.INTERRUPT -> main.post { HomeButtonShortcuts.release() }
|
||||
Relay.ARRIVAL -> bottomScreen?.onArrival(data.readInt(), data.readString() ?: return true, data.readLong())
|
||||
Relay.WINDOWS -> bottomScreen?.onWindows(Relay.decode(data.createByteArray() ?: return true))
|
||||
}
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
private fun stopBottomScreen() {
|
||||
bottomScreen?.stop()
|
||||
bottomScreen = null
|
||||
private fun trusts(uid: Int): Boolean {
|
||||
if (uid !in trusted) {
|
||||
if (!packageManager.getPackagesForUid(uid).orEmpty().contains(Relay.PACKAGE)) return false
|
||||
trusted += uid
|
||||
}
|
||||
return com.droiddeck.launcher.core.SteamIntegration.shortcutsEnabled(this)
|
||||
}
|
||||
|
||||
private fun onMain(event: KeyEvent): Boolean {
|
||||
// A key the companion already gave up on must not run later and leave a press without its release.
|
||||
val claimed = java.util.concurrent.atomic.AtomicBoolean(false)
|
||||
val task = java.util.concurrent.FutureTask {
|
||||
claimed.compareAndSet(false, true) &&
|
||||
(SystemKeyCapture.onKeyEvent(event) || HomeButtonShortcuts.onKeyEvent(this, event))
|
||||
}
|
||||
main.postAtFrontOfQueue(task)
|
||||
return try {
|
||||
task.get(KEY_TIMEOUT_MS, java.util.concurrent.TimeUnit.MILLISECONDS)
|
||||
} catch (e: java.util.concurrent.TimeoutException) {
|
||||
if (claimed.compareAndSet(false, true)) false else runCatching { task.get() }.getOrDefault(false)
|
||||
} catch (e: Exception) {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
getSystemService(InputManager::class.java).registerInputDeviceListener(this, main)
|
||||
if (BottomScreenGuests.supported()) bottomScreen = BottomScreenWatch(this).also { it.start() }
|
||||
}
|
||||
|
||||
override fun onBind(intent: Intent?): IBinder = binder
|
||||
|
||||
override fun onUnbind(intent: Intent?): Boolean {
|
||||
HomeButtonShortcuts.release()
|
||||
return super.onUnbind(intent)
|
||||
}
|
||||
|
||||
override fun onKeyEvent(event: KeyEvent) =
|
||||
SystemKeyCapture.onKeyEvent(event) || HomeButtonShortcuts.onKeyEvent(this, event)
|
||||
override fun onAccessibilityEvent(event: AccessibilityEvent?) { event?.let { bottomScreen?.onEvent(it) } }
|
||||
override fun onInterrupt() { HomeButtonShortcuts.release() }
|
||||
override fun onInputDeviceAdded(deviceId: Int) {}
|
||||
override fun onInputDeviceChanged(deviceId: Int) {}
|
||||
override fun onInputDeviceRemoved(deviceId: Int) { HomeButtonShortcuts.onDeviceRemoved(deviceId) }
|
||||
|
||||
override fun onUnbind(intent: Intent?): Boolean {
|
||||
HomeButtonShortcuts.release()
|
||||
stopBottomScreen()
|
||||
com.droiddeck.launcher.core.SteamIntegration.syncShortcutsListing(this)
|
||||
return super.onUnbind(intent)
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
HomeButtonShortcuts.release()
|
||||
stopBottomScreen()
|
||||
bottomScreen?.stop()
|
||||
bottomScreen = null
|
||||
getSystemService(InputManager::class.java).unregisterInputDeviceListener(this)
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val KEY_TIMEOUT_MS = 200L
|
||||
}
|
||||
}
|
||||
@@ -129,8 +129,9 @@ class SteamControllerBle(private val context: Context, router: InputRouter? = nu
|
||||
}
|
||||
}
|
||||
}
|
||||
g.disconnect()
|
||||
g.close()
|
||||
// Android can refuse these (BLUETOOTH_CONNECT revoked); an exception on this thread would end the app.
|
||||
runCatching { g.disconnect() }.onFailure { Log.w(TAG, "disconnect failed", it) }
|
||||
runCatching { g.close() }.onFailure { Log.w(TAG, "close failed", it) }
|
||||
Log.i(TAG, "disconnected: $why")
|
||||
listener?.invoke()
|
||||
}
|
||||
|
||||
@@ -390,7 +390,8 @@ object SteamTouchConfig {
|
||||
options: Options? = null,
|
||||
): File? {
|
||||
val dir = configDir(context) ?: return null
|
||||
val source = bindings.entries.fold(config.text ?: return null) { text, (ref, change) ->
|
||||
val base = config.text ?: if (config.file == null && bindings.isEmpty()) "\"controller_mappings\"\n{\n\t\"controller_type\"\t\t\"controller_mobile_touch\"\n}\n" else return null
|
||||
val source = bindings.entries.fold(base) { text, (ref, change) ->
|
||||
SteamTouchBindings.rewrite(text, ref, change) ?: text
|
||||
}
|
||||
val key = steamKey(context, appId)
|
||||
|
||||
@@ -0,0 +1,262 @@
|
||||
package com.droiddeck.launcher.input
|
||||
|
||||
import android.app.PendingIntent
|
||||
import android.content.BroadcastReceiver
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.IntentFilter
|
||||
import android.hardware.usb.UsbConstants
|
||||
import android.hardware.usb.UsbDevice
|
||||
import android.hardware.usb.UsbDeviceConnection
|
||||
import android.hardware.usb.UsbEndpoint
|
||||
import android.hardware.usb.UsbInterface
|
||||
import android.hardware.usb.UsbManager
|
||||
import android.os.Build
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.SystemClock
|
||||
import android.util.Log
|
||||
import android.view.InputDevice
|
||||
|
||||
/**
|
||||
* Reads a USB mouse from its HID interface, detaching it from Android meanwhile. Android only grants pointer
|
||||
* capture on the focused display, so an app shown elsewhere, as in REDMAGIC's cast mode, gets a cursor that
|
||||
* stops at the screen edge.
|
||||
*/
|
||||
class UsbMouse(private val context: Context, private val listener: Listener) {
|
||||
interface Listener {
|
||||
fun onMove(dx: Int, dy: Int)
|
||||
fun onButton(index: Int, down: Boolean)
|
||||
fun onWheel(steps: Int)
|
||||
fun onChanged()
|
||||
/** The mouse stopped responding while read here, so buttons held then never got their releases. */
|
||||
fun onLost()
|
||||
}
|
||||
|
||||
private val usb by lazy { context.getSystemService(Context.USB_SERVICE) as UsbManager }
|
||||
private val main = Handler(Looper.getMainLooper())
|
||||
private val permissionAction by lazy { context.packageName + ".USB_MOUSE_PERMISSION" }
|
||||
private val asked = mutableSetOf<String>()
|
||||
private val failed = mutableSetOf<String>()
|
||||
private var receiverRegistered = false
|
||||
@Volatile private var grab: Grab? = null
|
||||
private var lastReader: Thread? = null
|
||||
|
||||
val active: Boolean get() = grab != null
|
||||
|
||||
private val receiver = object : BroadcastReceiver() {
|
||||
override fun onReceive(context: Context, intent: Intent) {
|
||||
val granted = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)
|
||||
Log.i(TAG, "USB mouse access ${if (granted) "granted" else "denied"}")
|
||||
if (granted) listener.onChanged()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the mouse is now read here, setting it up on the reader thread; asks for access once per
|
||||
* plugged-in mouse. A mouse that fails setup after being claimed isn't tried again until it is replugged, since
|
||||
* releasing it re-adds Android's mouse, which would start another attempt.
|
||||
*/
|
||||
fun grab(): Boolean {
|
||||
if (grab != null) return true
|
||||
val (device, mouse) = findMouse() ?: return false
|
||||
if (device.deviceName in failed) return false
|
||||
if (!usb.hasPermission(device)) {
|
||||
if (asked.add(device.deviceName)) askPermission(device)
|
||||
return false
|
||||
}
|
||||
val endpoint = (0 until mouse.endpointCount).map(mouse::getEndpoint).firstOrNull {
|
||||
it.direction == UsbConstants.USB_DIR_IN && it.type == UsbConstants.USB_ENDPOINT_XFER_INT
|
||||
} ?: return false
|
||||
grab = Grab(device, mouse, endpoint, lastReader).also {
|
||||
lastReader = it.thread
|
||||
it.thread.start()
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
/** Hands the mouse back to Android. */
|
||||
fun release() {
|
||||
val current = grab ?: return
|
||||
grab = null
|
||||
current.cancel()
|
||||
}
|
||||
|
||||
fun close() {
|
||||
release()
|
||||
if (receiverRegistered) runCatching { context.unregisterReceiver(receiver) }
|
||||
receiverRegistered = false
|
||||
}
|
||||
|
||||
private fun findMouse(): Pair<UsbDevice, UsbInterface>? {
|
||||
val androidMice = InputDevice.getDeviceIds().asList().mapNotNull { InputDevice.getDevice(it) }
|
||||
.filter { !it.isVirtual && it.supportsSource(InputDevice.SOURCE_MOUSE) }
|
||||
.map { it.vendorId to it.productId }.toSet()
|
||||
return usb.deviceList.values.filter { (it.vendorId to it.productId) in androidMice }.firstNotNullOfOrNull { device ->
|
||||
(0 until device.interfaceCount).map(device::getInterface).firstOrNull(::isBootMouse)?.let { device to it }
|
||||
}
|
||||
}
|
||||
|
||||
private fun askPermission(device: UsbDevice) {
|
||||
if (!receiverRegistered) {
|
||||
val filter = IntentFilter(permissionAction)
|
||||
if (Build.VERSION.SDK_INT >= 33) context.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
|
||||
else context.registerReceiver(receiver, filter)
|
||||
receiverRegistered = true
|
||||
}
|
||||
val flags = if (Build.VERSION.SDK_INT >= 31) PendingIntent.FLAG_MUTABLE else 0
|
||||
val intent = PendingIntent.getBroadcast(context, 0, Intent(permissionAction).setPackage(context.packageName), flags)
|
||||
runCatching { usb.requestPermission(device, intent) }.onFailure {
|
||||
asked.remove(device.deviceName)
|
||||
Log.w(TAG, "requestPermission", it)
|
||||
}
|
||||
}
|
||||
|
||||
private inner class Grab(
|
||||
private val device: UsbDevice,
|
||||
private val mouse: UsbInterface,
|
||||
private val endpoint: UsbEndpoint,
|
||||
private val previous: Thread?,
|
||||
) {
|
||||
@Volatile private var running = true
|
||||
private val claimLock = Any()
|
||||
val thread = Thread(::run, "usb-mouse")
|
||||
|
||||
/** Once this returns, the reader either never claims the interface or sees the cancellation after claiming. */
|
||||
fun cancel() = synchronized(claimLock) { running = false }
|
||||
|
||||
// The reader owns the connection: closing it while a transfer is pending would free it under the transfer.
|
||||
// A previous reader may still hold the interface, which would make this claim fail.
|
||||
private fun run() {
|
||||
runCatching { previous?.join() }
|
||||
val connection = if (running) usb.openDevice(device) else null
|
||||
if (connection == null) {
|
||||
main.post { ended(markFailed = false) }
|
||||
return
|
||||
}
|
||||
var claimed = false
|
||||
var boot = false
|
||||
try {
|
||||
claimed = synchronized(claimLock) { running && connection.claimInterface(mouse, true) }
|
||||
if (!claimed) {
|
||||
main.post { ended(markFailed = false) }
|
||||
return
|
||||
}
|
||||
if (!running) return
|
||||
val format = setUp(connection)
|
||||
if (format == null) {
|
||||
main.post { ended(markFailed = true) }
|
||||
return
|
||||
}
|
||||
boot = format === HidMouseReport.BOOT
|
||||
if (!running) return
|
||||
Log.i(TAG, String.format(java.util.Locale.ROOT, "reading USB mouse %04x:%04x \"%s\" directly (%s)",
|
||||
device.vendorId, device.productId, device.productName, if (boot) "boot protocol" else "report ${format.reportId}"))
|
||||
read(connection, format)
|
||||
} finally {
|
||||
if (claimed) {
|
||||
if (boot) connection.controlTransfer(0x21, SET_PROTOCOL, HID_REPORT_PROTOCOL, mouse.id, null, 0, CONTROL_TIMEOUT_MS)
|
||||
connection.releaseInterface(mouse)
|
||||
}
|
||||
connection.close()
|
||||
}
|
||||
}
|
||||
|
||||
/** HID 1.11 7.2.6: a host must not assume the protocol a device is in, so it is set either way. */
|
||||
private fun setUp(connection: UsbDeviceConnection): HidMouseReport? {
|
||||
val descriptor = ByteArray(1024)
|
||||
val length = connection.controlTransfer(0x81, GET_DESCRIPTOR, HID_REPORT_DESCRIPTOR shl 8, mouse.id,
|
||||
descriptor, descriptor.size, CONTROL_TIMEOUT_MS)
|
||||
val parsed = if (length > 0) HidMouseReport.parse(descriptor.copyOf(length)) else null
|
||||
if (parsed != null && running &&
|
||||
connection.controlTransfer(0x21, SET_PROTOCOL, HID_REPORT_PROTOCOL, mouse.id, null, 0, CONTROL_TIMEOUT_MS) >= 0) return parsed
|
||||
val boot = running &&
|
||||
connection.controlTransfer(0x21, SET_PROTOCOL, HID_BOOT_PROTOCOL, mouse.id, null, 0, CONTROL_TIMEOUT_MS) >= 0
|
||||
return HidMouseReport.BOOT.takeIf { boot }
|
||||
}
|
||||
|
||||
private fun read(connection: UsbDeviceConnection, format: HidMouseReport) {
|
||||
val report = ByteArray(maxOf(endpoint.maxPacketSize, 8))
|
||||
var buttons = 0
|
||||
var failures = 0
|
||||
while (running) {
|
||||
val started = SystemClock.uptimeMillis()
|
||||
val length = connection.bulkTransfer(endpoint, report, report.size, READ_TIMEOUT_MS)
|
||||
if (length <= 0) {
|
||||
if (SystemClock.uptimeMillis() - started < READ_TIMEOUT_MS / 2 && ++failures >= MAX_FAILURES) {
|
||||
main.post { lost() }
|
||||
return
|
||||
}
|
||||
continue
|
||||
}
|
||||
failures = 0
|
||||
val state = format.decode(report, length) ?: continue
|
||||
val changed = buttons xor state.buttons
|
||||
buttons = state.buttons
|
||||
main.post { deliver(state, changed) }
|
||||
}
|
||||
}
|
||||
|
||||
private fun ended(markFailed: Boolean) {
|
||||
if (grab !== this) return
|
||||
if (markFailed) failed += device.deviceName
|
||||
Log.i(TAG, "USB mouse \"${device.productName}\" could not be set up")
|
||||
grab = null
|
||||
}
|
||||
|
||||
private fun deliver(state: HidMouseReport.State, changed: Int) {
|
||||
if (grab !== this) return
|
||||
if (state.dx != 0 || state.dy != 0) listener.onMove(state.dx, state.dy)
|
||||
for (i in 0 until BUTTONS) if (changed and (1 shl i) != 0) listener.onButton(i, state.buttons and (1 shl i) != 0)
|
||||
if (state.wheel != 0) listener.onWheel(state.wheel)
|
||||
}
|
||||
|
||||
private fun lost() {
|
||||
if (grab !== this) return
|
||||
failed += device.deviceName
|
||||
Log.i(TAG, "USB mouse stopped responding")
|
||||
grab = null
|
||||
listener.onLost()
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "UsbMouse"
|
||||
private const val GET_DESCRIPTOR = 0x06
|
||||
private const val SET_PROTOCOL = 0x0b
|
||||
private const val HID_BOOT_PROTOCOL = 0
|
||||
private const val HID_REPORT_PROTOCOL = 1
|
||||
private const val HID_REPORT_DESCRIPTOR = 0x22
|
||||
private const val SUBCLASS_BOOT = 1
|
||||
private const val PROTOCOL_MOUSE = 2
|
||||
private const val CONTROL_TIMEOUT_MS = 1000
|
||||
private const val READ_TIMEOUT_MS = 100
|
||||
private const val MAX_FAILURES = 5
|
||||
private const val BUTTONS = 5
|
||||
|
||||
private fun isBootMouse(iface: UsbInterface) = iface.interfaceClass == UsbConstants.USB_CLASS_HID &&
|
||||
iface.interfaceSubclass == SUBCLASS_BOOT && iface.interfaceProtocol == PROTOCOL_MOUSE
|
||||
|
||||
/**
|
||||
* A process killed while reading a mouse leaves it with no driver until it is replugged. Claiming without
|
||||
* force only succeeds when no driver has the interface, and releasing it reattaches Android's.
|
||||
*/
|
||||
fun returnLeftover(context: Context) {
|
||||
Thread({
|
||||
runCatching {
|
||||
val usb = context.getSystemService(Context.USB_SERVICE) as UsbManager
|
||||
for (device in usb.deviceList.values) {
|
||||
if (!usb.hasPermission(device)) continue
|
||||
val mouse = (0 until device.interfaceCount).map(device::getInterface).firstOrNull(::isBootMouse) ?: continue
|
||||
val connection = usb.openDevice(device) ?: continue
|
||||
if (connection.claimInterface(mouse, false)) {
|
||||
connection.releaseInterface(mouse)
|
||||
Log.i(TAG, "returned USB mouse \"${device.productName}\" to Android")
|
||||
}
|
||||
connection.close()
|
||||
}
|
||||
}.onFailure { Log.w(TAG, "returning a USB mouse to Android failed", it) }
|
||||
}, "usb-mouse-return").start()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
package com.droiddeck.launcher.lab
|
||||
|
||||
import android.app.Notification
|
||||
import android.app.NotificationChannel
|
||||
import android.app.NotificationManager
|
||||
import android.app.PendingIntent
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import com.droiddeck.launcher.FrontEndActivity
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.stores.download.StoreDownloadService
|
||||
|
||||
/**
|
||||
* Says what happened to a Lab build when the app starts, so a restart onto a new build does not
|
||||
* look like a crash, and a build Android or the safety checks turned off is not lost silently.
|
||||
*/
|
||||
object LabNotice {
|
||||
private const val CHANNEL_ID = "lab"
|
||||
private const val NOTIFICATION_ID = 4120
|
||||
|
||||
/** Where a start that just moved a Lab build into use opens; the agent that built it sets it. */
|
||||
@Volatile var openOnInstall: String = "updates"
|
||||
|
||||
fun started(context: Context) {
|
||||
val app = context.applicationContext
|
||||
val active = LabOverlay.active
|
||||
val skipped = LabOverlay.skipped
|
||||
val current = LabOverlay.current(app)
|
||||
when {
|
||||
LabOverlay.promoted && active != null ->
|
||||
post(app, app.getString(R.string.lab_installed_title), app.getString(R.string.lab_installed_text, active.label), openOnInstall)
|
||||
skipped == LabOverlay.SKIPPED_APP_IMAGE && current != null ->
|
||||
post(app, app.getString(R.string.lab_paused_title), app.getString(R.string.lab_paused_text, current.label), "updates")
|
||||
skipped == LabOverlay.Reason.OTHER_INSTALL.name || skipped == LabOverlay.Reason.DID_NOT_START.name -> {
|
||||
val reason = if (skipped == LabOverlay.Reason.OTHER_INSTALL.name) R.string.lab_off_other_install else R.string.lab_off_did_not_start
|
||||
post(app, app.getString(R.string.lab_off_title), app.getString(reason), "updates")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun post(app: Context, title: String, text: String, nav: String) {
|
||||
val manager = app.getSystemService(NotificationManager::class.java) ?: return
|
||||
manager.createNotificationChannel(NotificationChannel(CHANNEL_ID, app.getString(R.string.upd_lab), NotificationManager.IMPORTANCE_DEFAULT))
|
||||
val open = PendingIntent.getActivity(
|
||||
app, NOTIFICATION_ID,
|
||||
Intent(app, FrontEndActivity::class.java).putExtra(StoreDownloadService.EXTRA_NAV, nav)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_REORDER_TO_FRONT),
|
||||
PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT,
|
||||
)
|
||||
val notification = Notification.Builder(app, CHANNEL_ID)
|
||||
.setSmallIcon(R.drawable.ic_stat_session)
|
||||
.setContentTitle(title)
|
||||
.setContentText(text)
|
||||
.setStyle(Notification.BigTextStyle().bigText(text))
|
||||
.setContentIntent(open)
|
||||
.setAutoCancel(true)
|
||||
.build()
|
||||
runCatching { manager.notify(NOTIFICATION_ID, notification) }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,276 @@
|
||||
package com.droiddeck.launcher.lab
|
||||
|
||||
import android.app.Activity
|
||||
import android.app.Application
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.res.Resources
|
||||
import android.content.res.loader.ResourcesLoader
|
||||
import android.content.res.loader.ResourcesProvider
|
||||
import android.os.Build
|
||||
import android.os.Bundle
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.ParcelFileDescriptor
|
||||
import android.util.Log
|
||||
import androidx.annotation.RequiresApi
|
||||
import androidx.annotation.VisibleForTesting
|
||||
import com.droiddeck.launcher.BuildConfig
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* A Lab build: app code and resources an on-device agent built from this install's own commit,
|
||||
* loaded over the installed APK at startup so it can be tried without reinstalling or re-signing.
|
||||
*
|
||||
* `files/lab/next` holds a build waiting for the next start and `files/lab/active` the one in use,
|
||||
* each with `overlay.apk` (the build's dex files and linked resources) and `overlay.json`. A build
|
||||
* that is replaced, turned off or refused moves to `files/lab/builds`, so it can be used again.
|
||||
*/
|
||||
object LabOverlay {
|
||||
data class Info(val label: String, val baseCommit: String, val baseApk: String, val built: Long = 0)
|
||||
|
||||
enum class Reason { REPLACED, TURNED_OFF, OTHER_INSTALL, DID_NOT_START, UNREADABLE }
|
||||
|
||||
/** A build kept in `files/lab/builds`; [usable] when it was made for this install. */
|
||||
data class Saved(val dir: File, val info: Info?, val reason: Reason?, val usable: Boolean)
|
||||
|
||||
private const val TAG = "LabOverlay"
|
||||
private const val MAX_FAILED_STARTS = 2
|
||||
private const val STABLE_AFTER_MS = 10_000L
|
||||
private const val KEEP_BUILDS = 12
|
||||
const val SKIPPED_APP_IMAGE = "app image present"
|
||||
|
||||
/** The installed APK's commit; this class always comes from the APK, never from a Lab build. */
|
||||
val apkCommit: String = BuildConfig.SOURCE_COMMIT
|
||||
|
||||
@Volatile var active: Info? = null
|
||||
private set
|
||||
@Volatile var skipped: String? = null
|
||||
private set
|
||||
/** This start moved a newly staged build into use. */
|
||||
@Volatile var promoted = false
|
||||
private set
|
||||
|
||||
private var loader: Any? = null
|
||||
|
||||
@VisibleForTesting
|
||||
internal var injectDex: (ClassLoader, File) -> Unit = ::prependDex
|
||||
@VisibleForTesting
|
||||
internal var openResources: (File) -> Any? = { if (Build.VERSION.SDK_INT >= 30) createLoader(it) else null }
|
||||
@VisibleForTesting
|
||||
internal var appImage: (Context) -> Boolean = ::hasAppImage
|
||||
|
||||
fun root(context: Context) = File(context.filesDir, "lab")
|
||||
|
||||
/** Called from [Application.attachBaseContext], before any class the build may change is loaded. */
|
||||
fun load(app: Application, mainProcess: Boolean) {
|
||||
active = null
|
||||
skipped = null
|
||||
promoted = false
|
||||
try {
|
||||
val root = root(app)
|
||||
if (mainProcess) promoted = promote(root)
|
||||
val dir = File(root, "active")
|
||||
val apk = File(dir, "overlay.apk")
|
||||
val meta = File(dir, "overlay.json")
|
||||
if (!apk.isFile || !meta.isFile) return
|
||||
val info = parse(meta.readText()) ?: return refuse(root, mainProcess, Reason.UNREADABLE)
|
||||
if (!madeFor(app, info)) return refuse(root, mainProcess, Reason.OTHER_INSTALL)
|
||||
if (Build.VERSION.SDK_INT < 30) return skip("needs Android 11")
|
||||
// Classes in an app image are loaded before attachBaseContext and would ignore the overlay;
|
||||
// dd-lab-build recompiles the app without one (cmd package compile -m verify).
|
||||
if (appImage(app)) return skip(SKIPPED_APP_IMAGE)
|
||||
if (mainProcess) {
|
||||
val starts = failedStarts(root) + 1
|
||||
if (starts > MAX_FAILED_STARTS) return refuse(root, true, Reason.DID_NOT_START)
|
||||
File(root, "starts").writeText(starts.toString())
|
||||
}
|
||||
apk.setReadOnly()
|
||||
loader = openResources(apk)
|
||||
injectDex(app.classLoader, apk)
|
||||
active = info
|
||||
addLoader(app.resources)
|
||||
app.registerActivityLifecycleCallbacks(Callbacks(root, mainProcess))
|
||||
} catch (e: Throwable) {
|
||||
Log.w(TAG, "Lab build not loaded", e)
|
||||
skipped = e.message ?: e.javaClass.simpleName
|
||||
}
|
||||
}
|
||||
|
||||
/** The APK's path changes with every install and update of the app, so it pins a build to one install. */
|
||||
fun madeFor(context: Context, info: Info) = info.baseCommit == apkCommit && info.baseApk == context.applicationInfo.sourceDir
|
||||
|
||||
/** The build in `active`, whether or not this start loaded it. */
|
||||
fun current(context: Context): Info? = read(File(root(context), "active"))
|
||||
|
||||
/** A build staged for the next start. */
|
||||
fun pending(context: Context): Info? = read(File(root(context), "next"))
|
||||
|
||||
/** Kept builds, newest first. */
|
||||
fun saved(context: Context): List<Saved> = File(root(context), "builds").listFiles().orEmpty()
|
||||
.filter { File(it, "overlay.apk").isFile }
|
||||
.sortedByDescending { it.name.toLongOrNull() ?: 0L }
|
||||
.map { dir ->
|
||||
val info = read(dir)
|
||||
val reason = File(dir, "reason").takeIf { it.isFile }?.readText()?.trim()?.let { r -> Reason.entries.firstOrNull { it.name == r } }
|
||||
Saved(dir, info, reason, info != null && madeFor(context, info))
|
||||
}
|
||||
|
||||
/** Leaves the Lab build and restarts the app on the installed APK. */
|
||||
fun turnOff(context: Context) {
|
||||
val root = root(context)
|
||||
archive(root, File(root, "active"), Reason.TURNED_OFF)
|
||||
archive(root, File(root, "next"), Reason.TURNED_OFF)
|
||||
File(root, "next").deleteRecursively()
|
||||
File(root, "starts").delete()
|
||||
restart(context)
|
||||
}
|
||||
|
||||
/** Stages [build] for the next start and keeps a build that was waiting; the caller restarts the app. */
|
||||
fun stage(context: Context, build: Saved) {
|
||||
val root = root(context)
|
||||
val next = File(root, "next")
|
||||
val waiting = File(root, "next.replaced").apply { deleteRecursively() }
|
||||
next.renameTo(waiting)
|
||||
next.deleteRecursively()
|
||||
File(build.dir, "reason").delete()
|
||||
if (!build.dir.renameTo(next)) {
|
||||
waiting.renameTo(next)
|
||||
error("could not stage ${build.dir.name}")
|
||||
}
|
||||
archive(root, waiting, Reason.REPLACED)
|
||||
waiting.deleteRecursively()
|
||||
}
|
||||
|
||||
fun delete(build: Saved) {
|
||||
build.dir.deleteRecursively()
|
||||
}
|
||||
|
||||
/**
|
||||
* Android's background optimization can give the APK an app image again, which keeps a Lab
|
||||
* build from loading. Recompiling without one needs a shell, which the caller provides.
|
||||
*/
|
||||
fun needsRecompile(context: Context) = appImage(context)
|
||||
|
||||
fun recompileCommand(context: Context) = "cmd package compile -m verify -f ${context.packageName}"
|
||||
|
||||
fun restart(context: Context) {
|
||||
val launch = context.packageManager.getLaunchIntentForPackage(context.packageName)
|
||||
?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
|
||||
if (launch != null) context.startActivity(launch)
|
||||
Runtime.getRuntime().exit(0)
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun parse(json: String): Info? = runCatching {
|
||||
val o = JSONObject(json)
|
||||
Info(o.getString("label"), o.getString("baseCommit"), o.getString("baseApk"), o.optLong("built"))
|
||||
}.getOrNull()
|
||||
|
||||
private fun read(dir: File): Info? = File(dir, "overlay.json").takeIf { it.isFile && File(dir, "overlay.apk").isFile }?.let { parse(it.readText()) }
|
||||
|
||||
/** Moves `next` into use and keeps the build it replaces. Returns whether there was one to move. */
|
||||
@VisibleForTesting
|
||||
internal fun promote(root: File): Boolean {
|
||||
val next = File(root, "next")
|
||||
if (!File(next, "overlay.apk").isFile || !File(next, "overlay.json").isFile) return false
|
||||
val active = File(root, "active")
|
||||
archive(root, active, Reason.REPLACED)
|
||||
active.deleteRecursively()
|
||||
if (!next.renameTo(active)) return false
|
||||
File(root, "starts").delete()
|
||||
return true
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun archive(root: File, dir: File, reason: Reason) {
|
||||
if (!File(dir, "overlay.apk").isFile) return
|
||||
val builds = File(root, "builds").apply { mkdirs() }
|
||||
var stamp = System.currentTimeMillis()
|
||||
while (File(builds, stamp.toString()).exists()) stamp++
|
||||
val target = File(builds, stamp.toString())
|
||||
if (!dir.renameTo(target)) return
|
||||
File(target, "reason").writeText(reason.name)
|
||||
builds.listFiles().orEmpty().sortedByDescending { it.name.toLongOrNull() ?: 0L }.drop(KEEP_BUILDS).forEach { it.deleteRecursively() }
|
||||
}
|
||||
|
||||
@VisibleForTesting
|
||||
internal fun failedStarts(root: File) = File(root, "starts").takeIf { it.isFile }?.readText()?.trim()?.toIntOrNull() ?: 0
|
||||
|
||||
private fun refuse(root: File, mainProcess: Boolean, reason: Reason) {
|
||||
skipped = reason.name
|
||||
Log.w(TAG, "Lab build turned off: $reason")
|
||||
if (!mainProcess) return
|
||||
archive(root, File(root, "active"), reason)
|
||||
File(root, "starts").delete()
|
||||
File(root, "last-off-reason").writeText(reason.name)
|
||||
}
|
||||
|
||||
private fun skip(reason: String) {
|
||||
skipped = reason
|
||||
Log.w(TAG, "Lab build not loaded: $reason")
|
||||
}
|
||||
|
||||
private fun hasAppImage(context: Context): Boolean {
|
||||
val apk = File(context.applicationInfo.sourceDir)
|
||||
val oat = File(apk.parentFile, "oat")
|
||||
return oat.listFiles().orEmpty().any { File(it, "${apk.nameWithoutExtension}.art").isFile }
|
||||
}
|
||||
|
||||
@RequiresApi(30)
|
||||
private fun createLoader(apk: File): ResourcesLoader =
|
||||
ParcelFileDescriptor.open(apk, ParcelFileDescriptor.MODE_READ_ONLY).use { fd ->
|
||||
ResourcesLoader().apply { addProvider(ResourcesProvider.loadFromApk(fd)) }
|
||||
}
|
||||
|
||||
/** Gives [resources] the Lab build's resources; contexts made from them inherit it. */
|
||||
fun addLoader(resources: Resources) {
|
||||
if (Build.VERSION.SDK_INT < 30) return
|
||||
val current = loader as? ResourcesLoader ?: return
|
||||
resources.addLoaders(current)
|
||||
}
|
||||
|
||||
private fun prependDex(classLoader: ClassLoader, apk: File) {
|
||||
val pathList = field(Class.forName("dalvik.system.BaseDexClassLoader"), "pathList").get(classLoader)!!
|
||||
val elementsField = field(pathList.javaClass, "dexElements")
|
||||
@Suppress("UNCHECKED_CAST") val installed = elementsField.get(pathList) as Array<Any?>
|
||||
val errors = ArrayList<java.io.IOException>()
|
||||
val made = try {
|
||||
pathList.javaClass.getDeclaredMethod("makeDexElements", List::class.java, File::class.java, List::class.java, ClassLoader::class.java)
|
||||
.apply { isAccessible = true }.invoke(null, listOf(apk), null, errors, classLoader)
|
||||
} catch (_: NoSuchMethodException) {
|
||||
pathList.javaClass.getDeclaredMethod(
|
||||
"makeDexElements", List::class.java, File::class.java, List::class.java, ClassLoader::class.java, Boolean::class.javaPrimitiveType,
|
||||
).apply { isAccessible = true }.invoke(null, listOf(apk), null, errors, classLoader, false)
|
||||
}
|
||||
errors.firstOrNull()?.let { throw it }
|
||||
@Suppress("UNCHECKED_CAST") val added = made as Array<Any?>
|
||||
if (added.isEmpty()) error("no dex in ${apk.name}")
|
||||
val merged = java.lang.reflect.Array.newInstance(installed.javaClass.componentType!!, added.size + installed.size)
|
||||
System.arraycopy(added, 0, merged, 0, added.size)
|
||||
System.arraycopy(installed, 0, merged, added.size, installed.size)
|
||||
elementsField.set(pathList, merged)
|
||||
}
|
||||
|
||||
private fun field(type: Class<*>, name: String) = type.getDeclaredField(name).apply { isAccessible = true }
|
||||
|
||||
private class Callbacks(private val root: File, private val mainProcess: Boolean) : Application.ActivityLifecycleCallbacks {
|
||||
private var settled = false
|
||||
|
||||
override fun onActivityPreCreated(activity: Activity, savedInstanceState: Bundle?) = addLoader(activity.resources)
|
||||
|
||||
override fun onActivityResumed(activity: Activity) {
|
||||
if (settled || !mainProcess) return
|
||||
settled = true
|
||||
Handler(Looper.getMainLooper()).postDelayed({ File(root, "starts").delete() }, STABLE_AFTER_MS)
|
||||
}
|
||||
|
||||
override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
|
||||
override fun onActivityStarted(activity: Activity) = Unit
|
||||
override fun onActivityPaused(activity: Activity) = Unit
|
||||
override fun onActivityStopped(activity: Activity) = Unit
|
||||
override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
|
||||
override fun onActivityDestroyed(activity: Activity) = Unit
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,288 @@
|
||||
package com.droiddeck.launcher.playback
|
||||
|
||||
import android.content.ComponentName
|
||||
import android.content.Context
|
||||
import android.os.Bundle
|
||||
import android.net.Uri
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableLongStateOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.core.content.ContextCompat
|
||||
import androidx.media3.common.MediaItem
|
||||
import androidx.media3.common.MediaMetadata
|
||||
import androidx.media3.common.PlaybackParameters
|
||||
import androidx.media3.common.Player
|
||||
import androidx.media3.session.MediaController
|
||||
import androidx.media3.session.SessionToken
|
||||
import com.droiddeck.launcher.frontend.Soundtrack
|
||||
import com.google.common.util.concurrent.ListenableFuture
|
||||
import java.io.File
|
||||
|
||||
object SoundtrackController {
|
||||
var playing by mutableStateOf(false)
|
||||
private set
|
||||
var currentId by mutableStateOf<String?>(null)
|
||||
private set
|
||||
var title by mutableStateOf("")
|
||||
private set
|
||||
var shuffle by mutableStateOf(false)
|
||||
private set
|
||||
var repeat by mutableStateOf(Player.REPEAT_MODE_OFF)
|
||||
private set
|
||||
var durationMs by mutableStateOf(0L)
|
||||
private set
|
||||
var buffering by mutableStateOf(false)
|
||||
private set
|
||||
var volume by mutableStateOf(1f)
|
||||
private set
|
||||
|
||||
var activeCollection by mutableStateOf<Int?>(null)
|
||||
private set
|
||||
|
||||
var sleepEndsAt by mutableLongStateOf(0L)
|
||||
private set
|
||||
var sleepTrackEnd by mutableStateOf(false)
|
||||
private set
|
||||
|
||||
private var app: Context? = null
|
||||
private val removed: MutableSet<String> = java.util.Collections.synchronizedSet(HashSet())
|
||||
private var activeRoot: String? = null
|
||||
private var savedId: String? = null
|
||||
private var future: ListenableFuture<MediaController>? = null
|
||||
private var controller: MediaController? = null
|
||||
private val pending = ArrayList<(MediaController) -> Unit>()
|
||||
|
||||
private val listener = object : Player.Listener {
|
||||
override fun onEvents(player: Player, events: Player.Events) = sync(player)
|
||||
}
|
||||
|
||||
private val disconnect = object : MediaController.Listener {
|
||||
override fun onDisconnected(controller: MediaController) {
|
||||
if (this@SoundtrackController.controller === controller) {
|
||||
this@SoundtrackController.controller = null
|
||||
future = null
|
||||
reset()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun reset() {
|
||||
playing = false
|
||||
currentId = null
|
||||
title = ""
|
||||
durationMs = 0L
|
||||
buffering = false
|
||||
volume = 1f
|
||||
activeCollection = null
|
||||
}
|
||||
|
||||
private fun sync(player: Player) {
|
||||
playing = player.isPlaying
|
||||
buffering = player.playbackState == Player.STATE_BUFFERING
|
||||
currentId = player.currentMediaItem?.mediaId?.takeIf { player.mediaItemCount > 0 }
|
||||
title = player.mediaMetadata.title?.toString().orEmpty()
|
||||
shuffle = player.shuffleModeEnabled
|
||||
repeat = player.repeatMode
|
||||
durationMs = player.duration.takeIf { it > 0 } ?: 0L
|
||||
volume = player.volume
|
||||
if (!player.playWhenReady) sleepTrackEnd = false
|
||||
persistResume(player)
|
||||
}
|
||||
|
||||
private fun persistResume(player: Player) {
|
||||
val context = app ?: return
|
||||
val id = currentId ?: return
|
||||
if (activeCollection != null) return
|
||||
val root = activeRoot ?: SoundtrackSettings.resume(context)?.root?.takeIf { id.startsWith("$it/") }?.also { activeRoot = it } ?: return
|
||||
if (id != savedId || !player.isPlaying) {
|
||||
savedId = id
|
||||
SoundtrackSettings.saveResume(context, root, id, if (player.playbackState == Player.STATE_ENDED) 0L else player.currentPosition)
|
||||
}
|
||||
}
|
||||
|
||||
private fun applySettings(c: MediaController) {
|
||||
val context = app ?: return
|
||||
SoundtrackSettings.load(context)
|
||||
c.setPlaybackParameters(PlaybackParameters(SoundtrackSettings.speed, SoundtrackSettings.pitch))
|
||||
c.sendCustomCommand(SoundtrackService.SKIP_SILENCE, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, SoundtrackSettings.skipSilence) })
|
||||
sendEqualizer(c)
|
||||
c.sendCustomCommand(SoundtrackService.INGAME, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, com.droiddeck.launcher.session.SessionPrefs.soundtracksIngame(context)) })
|
||||
}
|
||||
|
||||
private fun sendEqualizer(c: MediaController) {
|
||||
c.sendCustomCommand(
|
||||
SoundtrackService.EQUALIZER,
|
||||
Bundle().apply {
|
||||
putBoolean(SoundtrackService.ARG_ON, SoundtrackSettings.eqOn)
|
||||
putIntArray(SoundtrackService.ARG_BANDS, SoundtrackSettings.bands.toIntArray())
|
||||
putInt(SoundtrackService.ARG_BASS, SoundtrackSettings.bass)
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
private fun run(context: Context, block: (MediaController) -> Unit) {
|
||||
app = context.applicationContext
|
||||
val live = controller
|
||||
if (live != null) { block(live); return }
|
||||
pending += block
|
||||
if (future != null) return
|
||||
val app = context.applicationContext
|
||||
val token = SessionToken(app, ComponentName(app, SoundtrackService::class.java))
|
||||
val built = MediaController.Builder(app, token).setListener(disconnect)
|
||||
.setConnectionHints(Bundle().apply { putBoolean(SoundtrackService.HINT_OWNER, true) }).buildAsync()
|
||||
future = built
|
||||
built.addListener({
|
||||
val ready = runCatching { built.get() }.getOrNull()
|
||||
if (ready == null) {
|
||||
future = null
|
||||
pending.clear()
|
||||
return@addListener
|
||||
}
|
||||
controller = ready
|
||||
ready.addListener(listener)
|
||||
applySettings(ready)
|
||||
sync(ready)
|
||||
val queued = pending.toList()
|
||||
pending.clear()
|
||||
queued.forEach { it(ready) }
|
||||
}, ContextCompat.getMainExecutor(app))
|
||||
}
|
||||
|
||||
fun connect(context: Context) = run(context) { }
|
||||
|
||||
fun position(): Long = controller?.currentPosition ?: 0L
|
||||
|
||||
fun belongsCollection(id: Int): Boolean = activeCollection == id && currentId != null
|
||||
|
||||
fun belongs(root: File?): Boolean {
|
||||
if (activeCollection != null) return false
|
||||
val id = currentId ?: return false
|
||||
return root != null && id.startsWith(root.path + "/")
|
||||
}
|
||||
|
||||
private fun items(album: Soundtrack.Album, albumTitle: String): List<MediaItem> {
|
||||
val cover = album.cover?.let { Uri.fromFile(it) }
|
||||
return album.tracks.map { t ->
|
||||
MediaItem.Builder()
|
||||
.setMediaId(t.file.path)
|
||||
.setMediaMetadata(
|
||||
MediaMetadata.Builder()
|
||||
.setTitle(t.title)
|
||||
.setArtist(t.artist.ifBlank { album.artist }.ifBlank { null })
|
||||
.setAlbumTitle(albumTitle)
|
||||
.setTrackNumber(t.number)
|
||||
.setDiscNumber(t.disc.takeIf { it > 0 })
|
||||
.setArtworkUri(cover)
|
||||
.setIsPlayable(true)
|
||||
.build(),
|
||||
)
|
||||
.build()
|
||||
}
|
||||
}
|
||||
|
||||
fun play(
|
||||
context: Context, album: Soundtrack.Album, albumTitle: String, startId: String?, shuffled: Boolean? = null,
|
||||
root: File? = null, startMs: Long = 0L, collection: Int? = null,
|
||||
) {
|
||||
val list = items(album, albumTitle)
|
||||
if (list.isEmpty()) return
|
||||
run(context) { c ->
|
||||
if (root != null && root.path in removed) return@run
|
||||
val start = list.indexOfFirst { it.mediaId == startId }.coerceAtLeast(0)
|
||||
root?.let { activeRoot = it.path }
|
||||
activeCollection = collection
|
||||
c.setMediaItems(list, start, startMs)
|
||||
shuffled?.let { c.shuffleModeEnabled = it }
|
||||
c.prepare()
|
||||
c.play()
|
||||
}
|
||||
}
|
||||
|
||||
fun allow(paths: Collection<String>) {
|
||||
removed.removeAll(paths.toSet())
|
||||
}
|
||||
|
||||
fun toggle(context: Context, album: Soundtrack.Album, albumTitle: String, root: File?, collection: Int? = null) {
|
||||
run(context) { c ->
|
||||
if (root != null && root.path in removed) return@run
|
||||
val mine = if (collection != null) belongsCollection(collection) else belongs(root)
|
||||
if (mine && c.mediaItemCount > 0) {
|
||||
if (c.isPlaying) c.pause() else {
|
||||
if (c.playbackState == Player.STATE_ENDED) c.seekToDefaultPosition(0)
|
||||
c.play()
|
||||
}
|
||||
} else {
|
||||
val saved = if (collection != null) null else root?.let { r -> SoundtrackSettings.resume(context)?.takeIf { it.root == r.path && album.tracks.any { t -> t.id == it.id } } }
|
||||
play(context, album, albumTitle, saved?.id ?: album.tracks.firstOrNull()?.id, root = root, startMs = saved?.positionMs ?: 0L, collection = collection)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun pause(context: Context) {
|
||||
val live = controller
|
||||
if (live != null) live.pause() else if (future != null) pending += { it.pause() }
|
||||
}
|
||||
|
||||
fun next(context: Context) = run(context) { it.seekToNext() }
|
||||
fun previous(context: Context) = run(context) { c -> if (c.currentPosition > 3000L) c.seekTo(0) else c.seekToPrevious() }
|
||||
fun seekTo(context: Context, ms: Long) = run(context) { it.seekTo(ms) }
|
||||
fun setShuffle(context: Context, on: Boolean) = run(context) { it.shuffleModeEnabled = on }
|
||||
fun cycleRepeat(context: Context) = run(context) {
|
||||
it.repeatMode = when (it.repeatMode) {
|
||||
Player.REPEAT_MODE_OFF -> Player.REPEAT_MODE_ALL
|
||||
Player.REPEAT_MODE_ALL -> Player.REPEAT_MODE_ONE
|
||||
else -> Player.REPEAT_MODE_OFF
|
||||
}
|
||||
}
|
||||
fun setVolume(context: Context, volume: Float) = run(context) { it.volume = volume.coerceIn(0f, 1f) }
|
||||
|
||||
fun setSpeed(context: Context, value: Float) {
|
||||
SoundtrackSettings.load(context)
|
||||
SoundtrackSettings.setSpeed(context, value)
|
||||
run(context) { it.setPlaybackParameters(PlaybackParameters(SoundtrackSettings.speed, SoundtrackSettings.pitch)) }
|
||||
}
|
||||
|
||||
fun setPitch(context: Context, value: Float) {
|
||||
SoundtrackSettings.load(context)
|
||||
SoundtrackSettings.setPitch(context, value)
|
||||
run(context) { it.setPlaybackParameters(PlaybackParameters(SoundtrackSettings.speed, SoundtrackSettings.pitch)) }
|
||||
}
|
||||
|
||||
fun setSkipSilence(context: Context, on: Boolean) {
|
||||
SoundtrackSettings.load(context)
|
||||
SoundtrackSettings.setSkipSilence(context, on)
|
||||
run(context) { it.sendCustomCommand(SoundtrackService.SKIP_SILENCE, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, on) }) }
|
||||
}
|
||||
|
||||
fun setEqualizer(context: Context, on: Boolean, bands: List<Int>, bass: Int) {
|
||||
SoundtrackSettings.load(context)
|
||||
SoundtrackSettings.setEqualizer(context, on, bands, bass)
|
||||
run(context) { sendEqualizer(it) }
|
||||
}
|
||||
|
||||
fun setIngame(context: Context, on: Boolean) {
|
||||
run(context) { it.sendCustomCommand(SoundtrackService.INGAME, Bundle().apply { putBoolean(SoundtrackService.ARG_ON, on) }) }
|
||||
}
|
||||
|
||||
fun setSleep(context: Context, minutes: Int) {
|
||||
sleepEndsAt = if (minutes > 0) System.currentTimeMillis() + minutes * 60_000L else 0L
|
||||
sleepTrackEnd = minutes < 0
|
||||
run(context) { it.sendCustomCommand(SoundtrackService.SLEEP, Bundle().apply { putInt(SoundtrackService.ARG_MINUTES, minutes) }) }
|
||||
}
|
||||
|
||||
fun sleepRemainingMs(): Long {
|
||||
val left = sleepEndsAt - System.currentTimeMillis()
|
||||
if (sleepEndsAt > 0L && left <= 0L) sleepEndsAt = 0L
|
||||
return left.coerceAtLeast(0L)
|
||||
}
|
||||
|
||||
fun stopIf(context: Context, root: File?) {
|
||||
root?.let { removed.add(it.path) }
|
||||
if (root == null || currentId?.startsWith(root.path + "/") != true) return
|
||||
run(context) { c ->
|
||||
c.stop()
|
||||
c.clearMediaItems()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
package com.droiddeck.launcher.playback
|
||||
|
||||
import android.app.PendingIntent
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.media.audiofx.BassBoost
|
||||
import android.media.audiofx.Equalizer
|
||||
import android.net.Uri
|
||||
import android.os.Bundle
|
||||
import android.os.Handler
|
||||
import android.os.Looper
|
||||
import android.os.Process
|
||||
import androidx.media3.common.AudioAttributes
|
||||
import androidx.media3.common.C
|
||||
import androidx.media3.common.MediaItem
|
||||
import androidx.media3.common.Player
|
||||
import androidx.media3.exoplayer.ExoPlayer
|
||||
import androidx.media3.session.CommandButton
|
||||
import androidx.media3.session.DefaultMediaNotificationProvider
|
||||
import androidx.media3.session.MediaSession
|
||||
import androidx.media3.session.MediaSessionService
|
||||
import androidx.media3.session.SessionCommand
|
||||
import androidx.media3.session.SessionResult
|
||||
import com.droiddeck.launcher.R
|
||||
import com.droiddeck.launcher.frontend.Soundtrack
|
||||
import com.google.common.collect.ImmutableList
|
||||
import com.google.common.util.concurrent.Futures
|
||||
import com.google.common.util.concurrent.ListenableFuture
|
||||
import java.io.File
|
||||
|
||||
private class EdgeButtonsProvider(context: Context) : DefaultMediaNotificationProvider(context) {
|
||||
override fun getMediaButtons(
|
||||
session: MediaSession, playerCommands: Player.Commands, customLayout: ImmutableList<CommandButton>, showPauseButton: Boolean,
|
||||
): ImmutableList<CommandButton> {
|
||||
val all = super.getMediaButtons(session, playerCommands, customLayout, showPauseButton)
|
||||
val custom = all.filter { it.sessionCommand != null }
|
||||
if (custom.size < 2) return all
|
||||
return ImmutableList.builder<CommandButton>()
|
||||
.add(custom.first())
|
||||
.addAll(all.filter { it.sessionCommand == null })
|
||||
.addAll(custom.drop(1))
|
||||
.build()
|
||||
}
|
||||
}
|
||||
|
||||
class SoundtrackService : MediaSessionService() {
|
||||
private var session: MediaSession? = null
|
||||
private var exo: ExoPlayer? = null
|
||||
private var equalizer: Equalizer? = null
|
||||
private var bassBoost: BassBoost? = null
|
||||
private var effectsSession = C.AUDIO_SESSION_ID_UNSET
|
||||
private var eqOn = false
|
||||
private var eqBands = IntArray(0)
|
||||
private var eqBass = 0
|
||||
private var sleepAtTrackEnd = false
|
||||
private val handler = Handler(Looper.getMainLooper())
|
||||
private val sleepRunnable = Runnable { session?.player?.pause() }
|
||||
private val covers = java.util.concurrent.Executors.newSingleThreadExecutor { r -> Thread(r, "soundtrack-cover").apply { isDaemon = true } }
|
||||
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
val player = ExoPlayer.Builder(this)
|
||||
.setAudioAttributes(mediaAttributes(), !com.droiddeck.launcher.session.SessionPrefs.soundtracksIngame(this))
|
||||
.setHandleAudioBecomingNoisy(true)
|
||||
.setWakeMode(androidx.media3.common.C.WAKE_MODE_LOCAL)
|
||||
.build()
|
||||
exo = player
|
||||
val sessionIntent = packageManager.getLaunchIntentForPackage(packageName)?.let {
|
||||
PendingIntent.getActivity(this, 0, it, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
|
||||
}
|
||||
player.addListener(object : Player.Listener {
|
||||
override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) = refreshButtons()
|
||||
override fun onRepeatModeChanged(repeatMode: Int) = refreshButtons()
|
||||
override fun onAudioSessionIdChanged(audioSessionId: Int) = applyEffects()
|
||||
override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
|
||||
if (!playWhenReady) sleepAtTrackEnd = false
|
||||
}
|
||||
override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
|
||||
refreshTrackCover(mediaItem)
|
||||
val ended = reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO || reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT
|
||||
if (sleepAtTrackEnd && ended) {
|
||||
sleepAtTrackEnd = false
|
||||
player.pause()
|
||||
}
|
||||
}
|
||||
})
|
||||
session = MediaSession.Builder(this, player).setCallback(Resolver()).apply { sessionIntent?.let { setSessionActivity(it) } }.build()
|
||||
setMediaNotificationProvider(EdgeButtonsProvider(this).apply { setSmallIcon(R.drawable.ic_soundtrack) })
|
||||
}
|
||||
|
||||
private fun mediaAttributes(): AudioAttributes =
|
||||
AudioAttributes.Builder().setUsage(C.USAGE_MEDIA).setContentType(C.AUDIO_CONTENT_TYPE_MUSIC).build()
|
||||
|
||||
private fun buttons(player: Player): ImmutableList<CommandButton> = ImmutableList.of(
|
||||
CommandButton.Builder()
|
||||
.setDisplayName(getString(R.string.soundtracks_shuffle))
|
||||
.setIconResId(if (player.shuffleModeEnabled) R.drawable.ic_shuffle_on else R.drawable.ic_shuffle_off)
|
||||
.setSessionCommand(SHUFFLE)
|
||||
.build(),
|
||||
CommandButton.Builder()
|
||||
.setDisplayName(
|
||||
getString(
|
||||
when (player.repeatMode) {
|
||||
Player.REPEAT_MODE_ALL -> R.string.soundtracks_repeat_all
|
||||
Player.REPEAT_MODE_ONE -> R.string.soundtracks_repeat_one
|
||||
else -> R.string.soundtracks_repeat_off
|
||||
},
|
||||
),
|
||||
)
|
||||
.setIconResId(
|
||||
when (player.repeatMode) {
|
||||
Player.REPEAT_MODE_ALL -> R.drawable.ic_repeat_all
|
||||
Player.REPEAT_MODE_ONE -> R.drawable.ic_repeat_one
|
||||
else -> R.drawable.ic_repeat_off
|
||||
},
|
||||
)
|
||||
.setSessionCommand(REPEAT)
|
||||
.build(),
|
||||
)
|
||||
|
||||
private fun hasPinnedArt(item: MediaItem): Boolean =
|
||||
item.mediaMetadata.artworkUri?.path.orEmpty().let { it.contains("/steam-art/") || it.contains("/soundtrack-art/") }
|
||||
|
||||
private fun refreshTrackCover(item: MediaItem?) {
|
||||
val current = item ?: return
|
||||
if (hasPinnedArt(current)) return
|
||||
val file = File(current.mediaId)
|
||||
covers.execute {
|
||||
val art = Soundtrack.trackCover(this, file) ?: return@execute
|
||||
handler.post {
|
||||
val player = exo ?: return@post
|
||||
val live = player.currentMediaItem ?: return@post
|
||||
val uri = Uri.fromFile(art)
|
||||
if (live.mediaId != current.mediaId || live.mediaMetadata.artworkUri == uri || hasPinnedArt(live)) return@post
|
||||
player.replaceMediaItem(
|
||||
player.currentMediaItemIndex,
|
||||
live.buildUpon().setMediaMetadata(live.mediaMetadata.buildUpon().setArtworkUri(uri).build()).build(),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun releaseEffects() {
|
||||
runCatching { equalizer?.release() }
|
||||
runCatching { bassBoost?.release() }
|
||||
equalizer = null
|
||||
bassBoost = null
|
||||
effectsSession = C.AUDIO_SESSION_ID_UNSET
|
||||
}
|
||||
|
||||
private fun applyEffects() {
|
||||
val id = exo?.audioSessionId ?: C.AUDIO_SESSION_ID_UNSET
|
||||
if (!eqOn || id == C.AUDIO_SESSION_ID_UNSET) {
|
||||
releaseEffects()
|
||||
return
|
||||
}
|
||||
if (id != effectsSession) {
|
||||
releaseEffects()
|
||||
effectsSession = id
|
||||
equalizer = runCatching { Equalizer(0, id) }.getOrNull()
|
||||
bassBoost = runCatching { BassBoost(0, id) }.getOrNull()
|
||||
}
|
||||
runCatching {
|
||||
equalizer?.let { eq ->
|
||||
val range = eq.bandLevelRange
|
||||
for (band in 0 until minOf(eq.numberOfBands.toInt(), eqBands.size)) {
|
||||
eq.setBandLevel(band.toShort(), eqBands[band].coerceIn(range[0].toInt(), range[1].toInt()).toShort())
|
||||
}
|
||||
eq.enabled = true
|
||||
}
|
||||
}
|
||||
runCatching {
|
||||
bassBoost?.let { boost ->
|
||||
if (boost.strengthSupported) boost.setStrength(eqBass.coerceIn(0, 1000).toShort())
|
||||
boost.enabled = eqBass > 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun setSleep(minutes: Int) {
|
||||
handler.removeCallbacks(sleepRunnable)
|
||||
sleepAtTrackEnd = false
|
||||
if (minutes > 0) handler.postDelayed(sleepRunnable, minutes * 60_000L)
|
||||
else if (minutes < 0) sleepAtTrackEnd = true
|
||||
}
|
||||
|
||||
private fun refreshButtons() {
|
||||
val live = session ?: return
|
||||
live.setCustomLayout(buttons(live.player))
|
||||
}
|
||||
|
||||
override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? = session
|
||||
|
||||
override fun onTaskRemoved(rootIntent: Intent?) {
|
||||
val player = session?.player
|
||||
if (player == null || !player.playWhenReady || player.mediaItemCount == 0 || player.playbackState == Player.STATE_ENDED) stopSelf()
|
||||
}
|
||||
|
||||
override fun onDestroy() {
|
||||
handler.removeCallbacks(sleepRunnable)
|
||||
covers.shutdownNow()
|
||||
releaseEffects()
|
||||
session?.let {
|
||||
it.player.release()
|
||||
it.release()
|
||||
}
|
||||
session = null
|
||||
super.onDestroy()
|
||||
}
|
||||
|
||||
companion object {
|
||||
const val HINT_OWNER = "droiddeck.owner"
|
||||
private val SHUFFLE = SessionCommand("droiddeck.shuffle", Bundle.EMPTY)
|
||||
private val REPEAT = SessionCommand("droiddeck.repeat", Bundle.EMPTY)
|
||||
val SKIP_SILENCE = SessionCommand("droiddeck.skipsilence", Bundle.EMPTY)
|
||||
val EQUALIZER = SessionCommand("droiddeck.equalizer", Bundle.EMPTY)
|
||||
val SLEEP = SessionCommand("droiddeck.sleep", Bundle.EMPTY)
|
||||
val INGAME = SessionCommand("droiddeck.ingame", Bundle.EMPTY)
|
||||
const val ARG_ON = "on"
|
||||
const val ARG_BANDS = "bands"
|
||||
const val ARG_BASS = "bass"
|
||||
const val ARG_MINUTES = "minutes"
|
||||
}
|
||||
|
||||
private inner class Resolver : MediaSession.Callback {
|
||||
private fun isOwner(controller: MediaSession.ControllerInfo) =
|
||||
controller.uid == Process.myUid() && controller.connectionHints.getBoolean(HINT_OWNER, false)
|
||||
|
||||
override fun onConnect(session: MediaSession, controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult =
|
||||
if (controller.uid == Process.myUid() || controller.isTrusted) {
|
||||
MediaSession.ConnectionResult.AcceptedResultBuilder(session)
|
||||
.setAvailableSessionCommands(
|
||||
MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon().add(SHUFFLE).add(REPEAT).add(SKIP_SILENCE).add(EQUALIZER).add(SLEEP).add(INGAME).build(),
|
||||
)
|
||||
.setCustomLayout(buttons(session.player))
|
||||
.build()
|
||||
} else {
|
||||
MediaSession.ConnectionResult.reject()
|
||||
}
|
||||
|
||||
override fun onCustomCommand(
|
||||
session: MediaSession, controller: MediaSession.ControllerInfo, customCommand: SessionCommand, args: Bundle,
|
||||
): ListenableFuture<SessionResult> {
|
||||
val player = session.player
|
||||
when (customCommand.customAction) {
|
||||
SHUFFLE.customAction -> player.shuffleModeEnabled = !player.shuffleModeEnabled
|
||||
REPEAT.customAction -> player.repeatMode = when (player.repeatMode) {
|
||||
Player.REPEAT_MODE_OFF -> Player.REPEAT_MODE_ALL
|
||||
Player.REPEAT_MODE_ALL -> Player.REPEAT_MODE_ONE
|
||||
else -> Player.REPEAT_MODE_OFF
|
||||
}
|
||||
SKIP_SILENCE.customAction, EQUALIZER.customAction, SLEEP.customAction, INGAME.customAction -> {
|
||||
if (!isOwner(controller)) return Futures.immediateFuture(SessionResult(SessionResult.RESULT_ERROR_PERMISSION_DENIED))
|
||||
when (customCommand.customAction) {
|
||||
SKIP_SILENCE.customAction -> exo?.skipSilenceEnabled = args.getBoolean(ARG_ON)
|
||||
INGAME.customAction -> exo?.setAudioAttributes(mediaAttributes(), !args.getBoolean(ARG_ON))
|
||||
EQUALIZER.customAction -> {
|
||||
eqOn = args.getBoolean(ARG_ON)
|
||||
eqBands = args.getIntArray(ARG_BANDS) ?: IntArray(0)
|
||||
eqBass = args.getInt(ARG_BASS)
|
||||
applyEffects()
|
||||
}
|
||||
else -> setSleep(args.getInt(ARG_MINUTES))
|
||||
}
|
||||
}
|
||||
else -> return Futures.immediateFuture(SessionResult(SessionResult.RESULT_ERROR_NOT_SUPPORTED))
|
||||
}
|
||||
return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
|
||||
}
|
||||
|
||||
override fun onAddMediaItems(
|
||||
mediaSession: MediaSession, controller: MediaSession.ControllerInfo, mediaItems: MutableList<MediaItem>,
|
||||
): ListenableFuture<MutableList<MediaItem>> {
|
||||
if (!isOwner(controller)) return Futures.immediateFailedFuture(SecurityException("Only DroidDeck can queue soundtrack files"))
|
||||
val resolved = mediaItems.mapNotNull { item ->
|
||||
val file = File(item.mediaId)
|
||||
if (Soundtrack.isAudio(file)) item.buildUpon().setUri(Uri.fromFile(file)).build() else null
|
||||
}.toMutableList()
|
||||
return Futures.immediateFuture(resolved)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package com.droiddeck.launcher.playback
|
||||
|
||||
import android.content.Context
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableFloatStateOf
|
||||
import androidx.compose.runtime.mutableIntStateOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.setValue
|
||||
|
||||
object SoundtrackSettings {
|
||||
const val MIN_RATE = 0.5f
|
||||
const val MAX_RATE = 2f
|
||||
|
||||
var speed by mutableFloatStateOf(1f)
|
||||
private set
|
||||
var pitch by mutableFloatStateOf(1f)
|
||||
private set
|
||||
var skipSilence by mutableStateOf(false)
|
||||
private set
|
||||
var eqOn by mutableStateOf(false)
|
||||
private set
|
||||
var bands by mutableStateOf<List<Int>>(emptyList())
|
||||
private set
|
||||
var bass by mutableIntStateOf(0)
|
||||
private set
|
||||
|
||||
class Resume(val root: String, val id: String, val positionMs: Long)
|
||||
|
||||
private var loaded = false
|
||||
|
||||
private fun prefs(context: Context) = context.applicationContext.getSharedPreferences("soundtrack_settings", Context.MODE_PRIVATE)
|
||||
|
||||
@Synchronized
|
||||
fun load(context: Context) {
|
||||
if (loaded) return
|
||||
loaded = true
|
||||
val p = prefs(context)
|
||||
speed = p.getFloat("speed", 1f).coerceIn(MIN_RATE, MAX_RATE)
|
||||
pitch = p.getFloat("pitch", 1f).coerceIn(MIN_RATE, MAX_RATE)
|
||||
skipSilence = p.getBoolean("skipSilence", false)
|
||||
eqOn = p.getBoolean("eqOn", false)
|
||||
bands = p.getString("bands", "").orEmpty().split(',').mapNotNull { it.trim().toIntOrNull() }
|
||||
bass = p.getInt("bass", 0).coerceIn(0, 1000)
|
||||
}
|
||||
|
||||
fun setSpeed(context: Context, value: Float) {
|
||||
speed = value.coerceIn(MIN_RATE, MAX_RATE)
|
||||
prefs(context).edit().putFloat("speed", speed).apply()
|
||||
}
|
||||
|
||||
fun setPitch(context: Context, value: Float) {
|
||||
pitch = value.coerceIn(MIN_RATE, MAX_RATE)
|
||||
prefs(context).edit().putFloat("pitch", pitch).apply()
|
||||
}
|
||||
|
||||
fun setSkipSilence(context: Context, on: Boolean) {
|
||||
skipSilence = on
|
||||
prefs(context).edit().putBoolean("skipSilence", on).apply()
|
||||
}
|
||||
|
||||
fun setEqualizer(context: Context, on: Boolean, levels: List<Int>, bassStrength: Int) {
|
||||
eqOn = on
|
||||
bands = levels
|
||||
bass = bassStrength.coerceIn(0, 1000)
|
||||
prefs(context).edit().putBoolean("eqOn", on).putString("bands", levels.joinToString(",")).putInt("bass", bass).apply()
|
||||
}
|
||||
|
||||
fun resume(context: Context): Resume? {
|
||||
val p = prefs(context)
|
||||
val root = p.getString("resumeRoot", null) ?: return null
|
||||
val id = p.getString("resumeId", null) ?: return null
|
||||
return Resume(root, id, p.getLong("resumePosition", 0L))
|
||||
}
|
||||
|
||||
fun saveResume(context: Context, root: String, id: String, positionMs: Long) {
|
||||
prefs(context).edit().putString("resumeRoot", root).putString("resumeId", id).putLong("resumePosition", positionMs.coerceAtLeast(0L)).apply()
|
||||
}
|
||||
}
|
||||
@@ -232,11 +232,24 @@ object BattleNet {
|
||||
}
|
||||
|
||||
internal fun hostFolder(context: Context, path: String): File? {
|
||||
val drive = Regex("""^([CcZz]):[\\/](.*)$""").matchEntire(path.trim()) ?: return null
|
||||
val drive = Regex("""^([A-Za-z]):[\\/](.*)$""").matchEntire(path.trim()) ?: return null
|
||||
val relative = drive.groupValues[2].replace('\\', '/').trim('/')
|
||||
if (relative.isEmpty() || relative.split('/').any { it == ".." }) return null
|
||||
return if (drive.groupValues[1].equals("c", ignoreCase = true)) File(prefix(context), "pfx/drive_c/$relative")
|
||||
else com.droiddeck.launcher.frontend.AddedGames.hostPath(context, "/$relative")
|
||||
val letter = drive.groupValues[1].lowercase()
|
||||
if (letter == "c") return File(prefix(context), "pfx/drive_c/$relative")
|
||||
val link = File(prefix(context), "pfx/dosdevices/$letter:").toPath()
|
||||
val mapped = runCatching { java.nio.file.Files.readSymbolicLink(link).toString() }.getOrNull()
|
||||
val target = when {
|
||||
mapped == null -> if (letter == "z") "/" else return null
|
||||
mapped.startsWith("/") -> mapped
|
||||
else -> {
|
||||
val rootfs = LinuxRuntime.rootDir(context).toPath().toAbsolutePath().normalize()
|
||||
val resolved = link.toAbsolutePath().parent.resolve(mapped).normalize()
|
||||
if (!resolved.startsWith(rootfs)) return null
|
||||
"/" + rootfs.relativize(resolved).joinToString("/")
|
||||
}
|
||||
}.trimEnd('/')
|
||||
return com.droiddeck.launcher.frontend.AddedGames.hostPath(context, "$target/$relative")
|
||||
}
|
||||
|
||||
private val KEY = Regex("""^\[(.+)\](?:\s+\d+)?\s*$""")
|
||||
@@ -361,7 +374,7 @@ object BattleNet {
|
||||
val guestPrefix = added.guestPath(context, prefix(context)) ?: return null
|
||||
val crc = java.util.zip.CRC32().apply { update("\"$guestExe\"${game.name}".toByteArray()) }.value
|
||||
val appId = com.droiddeck.launcher.session.SessionPrefs.addedGameAppId(context, game.folder.path, crc or 0x80000000L)
|
||||
val exe = added.candidates(game.folder).firstOrNull() ?: client
|
||||
val exe = added.candidates(game.folder, reuse = true).firstOrNull() ?: client
|
||||
return com.droiddeck.launcher.frontend.AddedGames.Game(
|
||||
game.folder, game.name, exe, guestExe, guestDir, appId, (appId shl 32) or 0x02000000L, listOf(exe),
|
||||
source = com.droiddeck.launcher.stores.Store.BATTLENET.id, storeId = game.uid,
|
||||
|
||||
@@ -182,6 +182,7 @@ object BwrapSpawner {
|
||||
val argv = request.getJSONArray("argv").let { a -> (0 until a.length()).map { a.getString(it) } }
|
||||
val env = LinkedHashMap<String, String>()
|
||||
request.optJSONObject("env")?.let { e -> e.keys().forEach { k -> env[k] = e.getString(k) } }
|
||||
withoutRootfsSettings(env, rootfs)
|
||||
val envTool = request.optString("envTool").takeIf { it.startsWith("/") }
|
||||
if (envTool == null && binds.any { it.guest == "/dev" }) gpu(rootfs, root, 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) }
|
||||
@@ -191,6 +192,24 @@ object BwrapSpawner {
|
||||
return Plan(root, binds, request.optString("cwd", "/").ifEmpty { "/" }, argv, env, envTool ?: "/usr/bin/env")
|
||||
}
|
||||
|
||||
private val ROOTFS_PIPEWIRE = listOf("PIPEWIRE_MODULE_DIR", "SPA_PLUGIN_DIR", "PIPEWIRE_CONFIG_DIR")
|
||||
|
||||
/**
|
||||
* The session's Flatpak passes settings for the session's own root on: the native hook's,
|
||||
* DroidDeck's PipeWire build, which a runtime does not have (its apps found no PipeWire plugins),
|
||||
* and the session's video driver for SDL.
|
||||
*/
|
||||
internal fun withoutRootfsSettings(env: MutableMap<String, String>, rootfs: String) {
|
||||
env.keys.removeAll { it.startsWith("DDNATV_") }
|
||||
for (key in ROOTFS_PIPEWIRE) if (env[key]?.startsWith("/usr/local/lib/droiddeck-pipewire") == true) env.remove(key)
|
||||
// the session's choice of X11 for SDL, in an app that Flatpak gave Wayland and no X display
|
||||
if (env["SDL_VIDEODRIVER"] == "x11" && env["DISPLAY"].isNullOrEmpty() && !env["WAYLAND_DISPLAY"].isNullOrEmpty()) env.remove("SDL_VIDEODRIVER")
|
||||
env["LD_PRELOAD"]?.let { preload ->
|
||||
val kept = preload.split(':').filter { it.isNotEmpty() && it != rootfs && !it.startsWith("$rootfs/") }
|
||||
if (kept.isEmpty()) env.remove("LD_PRELOAD") else env["LD_PRELOAD"] = kept.joinToString(":")
|
||||
}
|
||||
}
|
||||
|
||||
private const val GPU_DIR = "/run/droiddeck-gpu"
|
||||
|
||||
private val LIB_DIRS = listOf("usr/lib/aarch64-linux-gnu", "usr/lib")
|
||||
@@ -351,22 +370,201 @@ object BwrapSpawner {
|
||||
try { Os.chmod(f.path, mode) } catch (e: Exception) { }
|
||||
}
|
||||
|
||||
private val SANDBOX_LOADERS = listOf("/usr/lib/aarch64-linux-gnu/ld-linux-aarch64.so.1", "/usr/lib/ld-linux-aarch64.so.1",
|
||||
"/lib/ld-linux-aarch64.so.1", "/lib64/ld-linux-aarch64.so.1")
|
||||
private val SANDBOX_LIBCS = listOf("/usr/lib/aarch64-linux-gnu/libc.so.6", "/usr/lib/libc.so.6", "/lib/aarch64-linux-gnu/libc.so.6")
|
||||
private val SANDBOX_LIB_DIRS = listOf("/app/lib/aarch64-linux-gnu", "/app/lib", "/usr/lib/aarch64-linux-gnu", "/usr/lib")
|
||||
private val seccompPatched = java.util.concurrent.ConcurrentHashMap.newKeySet<String>()
|
||||
|
||||
/**
|
||||
* The sandbox started by the runtime's own glibc loader with the native hook, which maps the
|
||||
* sandbox's mounts; null when the runtime cannot load the hook (older glibc), so proot runs it.
|
||||
*/
|
||||
private fun nativeLaunch(context: Context, plan: Plan): Pair<List<String>, Map<String, String>>? {
|
||||
val rootfs = LinuxRuntime.rootDir(context)
|
||||
val sandbox = plan.root.path
|
||||
fun host(guest: String) = File(hostPath(plan.binds, sandbox, guest))
|
||||
if (!hasEnvTool(plan)) {
|
||||
val program = plan.argv.firstOrNull()?.takeIf { it.startsWith("/") }?.let(::host)?.canonicalFile
|
||||
?.takeIf { it.isFile && isStaticElf(it) } ?: return null
|
||||
if (!linkMounts(plan)) return null
|
||||
return (listOf(program.path) + plan.argv.drop(1)) to plan.env
|
||||
}
|
||||
val loader = SANDBOX_LOADERS.map(::host).firstOrNull { it.isFile }?.canonicalFile ?: return null
|
||||
val libc = SANDBOX_LIBCS.map(::host).firstOrNull { it.isFile }?.canonicalFile ?: return null
|
||||
val hook = NativeGuest.hook(rootfs)
|
||||
val need = glibcMinor(hook, GLIBC_NEED) { it.maxOrNull() } ?: return null
|
||||
val have = glibcMinor(libc, GLIBC_RELEASE) { it.firstOrNull() } ?: return null
|
||||
if (have < need) {
|
||||
Log.i(TAG, "native userland: this runtime's glibc 2.$have cannot load the hook (2.$need); proot runs the sandbox")
|
||||
return null
|
||||
}
|
||||
for (file in listOf(loader, libc)) {
|
||||
val key = "${file.path}:${file.length()}:${file.lastModified()}"
|
||||
if (key in seccompPatched) continue
|
||||
// an unpatched loader or libc dies under Android's filter before the hook loads: proot runs it
|
||||
val patched = runCatching { ElfSeccompPatch.patchFile(file) }
|
||||
.onFailure { Log.e(TAG, "native userland: could not patch $file for Android's seccomp filter; proot runs the sandbox", it) }
|
||||
if (patched.isFailure) return null
|
||||
seccompPatched.add("${file.path}:${file.length()}:${file.lastModified()}")
|
||||
}
|
||||
val program = host(plan.envTool).canonicalFile.takeIf { it.isFile } ?: return null
|
||||
if (!linkMounts(plan)) return null
|
||||
writeRunpathConf(plan, ::host)
|
||||
val launch = listOf(loader.path, "--argv0", program.name, program.path, "-i") +
|
||||
plan.env.map { (k, v) -> "$k=$v" } + plan.argv
|
||||
val env = linkedMapOf(
|
||||
"DDNATV_ROOT" to sandbox,
|
||||
"DDNATV_LINK_ROOT" to rootfs.path,
|
||||
"DDNATV_BINDS" to plan.binds.joinToString("|") { "${it.host}:${it.guest}" },
|
||||
"DDNATV_HOSTNAME" to SessionPrefs.guestHostname(context),
|
||||
"LD_LIBRARY_PATH" to SANDBOX_LIB_DIRS.map(::host).filter { it.isDirectory }.joinToString(":") { it.path },
|
||||
"LD_PRELOAD" to hook.path,
|
||||
).filterValues { it.isNotEmpty() }
|
||||
return (NativeGuest.simulator(rootfs)?.let { it + launch } ?: launch) to env
|
||||
}
|
||||
|
||||
private val runpathDirs = java.util.concurrent.ConcurrentHashMap<String, List<String>>()
|
||||
|
||||
/**
|
||||
* ld.so opens a library's absolute RUNPATH (libpulse's pulseaudio/ directory) without the hook,
|
||||
* on Android's own filesystem, so those directories are listed for the hook in the sandbox's
|
||||
* ld.so.conf too, as [NativeGuest.syncLibraryDirs] does for the rootfs. A checkout never changes.
|
||||
*/
|
||||
private fun writeRunpathConf(plan: Plan, host: (String) -> File) {
|
||||
val confDir = inRoot(plan.root, "/run/flatpak/ld.so.conf.d")?.takeIf { it.isDirectory } ?: return
|
||||
val dirs = sortedSetOf<String>()
|
||||
for (top in listOf("/usr/lib", "/app/lib")) {
|
||||
val real = host(top).takeIf { it.isDirectory }?.canonicalFile ?: continue
|
||||
dirs += runpathDirs.getOrPut(real.path) {
|
||||
real.walkTopDown().maxDepth(4).onEnter { !Files.isSymbolicLink(it.toPath()) }
|
||||
.filter { it.isFile && ".so" in it.name && !Files.isSymbolicLink(it.toPath()) }
|
||||
.flatMap { runCatching { ElfRunpath.read(it) }.getOrDefault(emptyList()) }
|
||||
.filter { it.startsWith("/usr/") || it.startsWith("/app/") || it.startsWith("/lib") }
|
||||
.distinct().toList()
|
||||
}
|
||||
}
|
||||
if (dirs.isEmpty()) return
|
||||
runCatching { File(confDir, "runtime-999-droiddeck-runpath.conf").writeText(dirs.joinToString("\n", postfix = "\n")) }
|
||||
}
|
||||
|
||||
/** A runtime extension's apply_extra runs in a sandbox with nothing but the extension itself. */
|
||||
private fun hasEnvTool(plan: Plan): Boolean =
|
||||
File(hostPath(plan.binds, plan.root.path, plan.envTool)).let { it.exists() || Files.isSymbolicLink(it.toPath()) }
|
||||
|
||||
internal fun isStaticElf(file: File): Boolean = try {
|
||||
java.io.RandomAccessFile(file, "r").use { f ->
|
||||
val head = ByteArray(64).also { f.readFully(it) }
|
||||
if (head[0] != 0x7f.toByte() || head[1] != 'E'.code.toByte() || head[4] != 2.toByte() || head[5] != 1.toByte()) return false
|
||||
val le = java.nio.ByteBuffer.wrap(head).order(java.nio.ByteOrder.LITTLE_ENDIAN)
|
||||
val phoff = le.getLong(32)
|
||||
val phentsize = le.getShort(54).toInt() and 0xffff
|
||||
val phnum = le.getShort(56).toInt() and 0xffff
|
||||
val entry = ByteArray(4)
|
||||
(0 until phnum).none { i ->
|
||||
f.seek(phoff + i.toLong() * phentsize)
|
||||
f.readFully(entry)
|
||||
java.nio.ByteBuffer.wrap(entry).order(java.nio.ByteOrder.LITTLE_ENDIAN).int == 3 // PT_INTERP
|
||||
}
|
||||
}
|
||||
} catch (_: java.io.IOException) {
|
||||
false
|
||||
}
|
||||
|
||||
/**
|
||||
* The kernel follows paths the hook does not see (ld.so, symbolic links), so each top-level
|
||||
* mount of the sandbox is also a link to its source in the sandbox's own root, and the
|
||||
* sandbox's links with absolute guest targets are made relative, which reaches them through those.
|
||||
* False when a mount's place could not be made; proot then runs the sandbox, whose mounts hide
|
||||
* whatever was left at their places.
|
||||
*/
|
||||
private fun linkMounts(plan: Plan): Boolean {
|
||||
val root = plan.root.toPath()
|
||||
plan.root.walkTopDown().onEnter { !Files.isSymbolicLink(it.toPath()) }.map { it.toPath() }
|
||||
.filter { Files.isSymbolicLink(it) }.toList().forEach { link ->
|
||||
runCatching {
|
||||
val target = Files.readSymbolicLink(link).toString()
|
||||
if (!target.startsWith("/")) return@runCatching
|
||||
Files.delete(link)
|
||||
Files.createSymbolicLink(link, link.parent.relativize(root.resolve(target.removePrefix("/"))))
|
||||
}
|
||||
}
|
||||
// a mount inside another mount (a GL extension at /usr/lib/aarch64-linux-gnu/GL) needs its own
|
||||
// place: the links of the mounts it is in become directories of links to their entries
|
||||
val entryLinks = HashSet<java.nio.file.Path>()
|
||||
for (bind in plan.binds.sortedBy { it.guest.length }) {
|
||||
if (bind.guest == "/") continue
|
||||
val at = try {
|
||||
mountPlace(plan.root, bind.guest, entryLinks)?.also { at ->
|
||||
val path = at.toPath()
|
||||
if (path in entryLinks) {
|
||||
Files.delete(path)
|
||||
entryLinks.remove(path)
|
||||
}
|
||||
}
|
||||
} catch (e: java.io.IOException) {
|
||||
Log.e(TAG, "native userland: could not make a place for ${bind.guest}; proot runs the sandbox", e)
|
||||
return false
|
||||
} ?: continue
|
||||
val path = at.toPath()
|
||||
if (at.exists() || Files.isSymbolicLink(path)) continue
|
||||
at.parentFile?.mkdirs()
|
||||
runCatching { Files.createSymbolicLink(path, java.nio.file.Paths.get(bind.host)) }
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
private fun mountPlace(root: File, guest: String, entryLinks: MutableSet<java.nio.file.Path>): File? {
|
||||
val parts = guest.split('/').filter { it.isNotEmpty() }
|
||||
var f = root
|
||||
for ((i, part) in parts.withIndex()) {
|
||||
if (part == "..") return null
|
||||
f = File(f, part)
|
||||
val path = f.toPath()
|
||||
if (i == parts.lastIndex || !Files.isSymbolicLink(path)) continue
|
||||
val target = Files.readSymbolicLink(path)
|
||||
// a link of the sandbox's own tree, made relative above, is not a mount
|
||||
if (!target.isAbsolute) return null
|
||||
Files.delete(path)
|
||||
entryLinks.remove(path)
|
||||
Files.createDirectory(path)
|
||||
target.toFile().listFiles()?.forEach { entry ->
|
||||
val link = path.resolve(entry.name)
|
||||
Files.createSymbolicLink(link, entry.toPath())
|
||||
entryLinks.add(link)
|
||||
}
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
private fun run(context: Context, plan: Plan, client: LocalSocket, out: DataOutputStream, id: Int) {
|
||||
val cmd = LinuxRuntime.prootPrefix(context, plan.root, plan.cwd)
|
||||
val verbose = plan.env["DROIDDECK_PROOT_VERBOSE"]?.toIntOrNull()
|
||||
if (verbose != null) { cmd.add(1, "-v"); cmd.add(2, verbose.toString()) }
|
||||
plan.binds.forEach { cmd.add("-b"); cmd.add(it.spec) }
|
||||
cmd.add(plan.envTool)
|
||||
cmd.add("-i")
|
||||
plan.env.forEach { (k, v) -> cmd.add("$k=$v") }
|
||||
cmd.addAll(plan.argv)
|
||||
val builder = ProcessBuilder(cmd).redirectErrorStream(true).directory(plan.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 native = if (NativeGuest.forSession(context)) nativeLaunch(context, plan) else null
|
||||
val builder = if (native != null) {
|
||||
ProcessBuilder(native.first).redirectErrorStream(true)
|
||||
.directory(File(hostPath(plan.binds, plan.root.path, plan.cwd)).takeIf { it.isDirectory } ?: plan.root)
|
||||
.also { b -> b.environment().apply { clear(); putAll(native.second) } }
|
||||
} else {
|
||||
val cmd = LinuxRuntime.prootPrefix(context, plan.root, plan.cwd)
|
||||
if (verbose != null) { cmd.add(1, "-v"); cmd.add(2, verbose.toString()) }
|
||||
plan.binds.forEach { cmd.add("-b"); cmd.add(it.spec) }
|
||||
val envTool = hasEnvTool(plan)
|
||||
if (envTool) {
|
||||
cmd.add(plan.envTool)
|
||||
cmd.add("-i")
|
||||
plan.env.forEach { (k, v) -> cmd.add("$k=$v") }
|
||||
}
|
||||
cmd.addAll(plan.argv)
|
||||
ProcessBuilder(cmd).redirectErrorStream(true).directory(plan.root).also { b ->
|
||||
b.environment().apply {
|
||||
clear()
|
||||
if (!envTool) putAll(plan.env)
|
||||
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 process = builder.start()
|
||||
val pid = HostProcess.pidOf(process)
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import java.io.File
|
||||
import java.io.RandomAccessFile
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
|
||||
/** The absolute DT_RUNPATH and DT_RPATH directories of a 64-bit little-endian ELF object. */
|
||||
object ElfRunpath {
|
||||
private const val PT_LOAD = 1
|
||||
private const val PT_DYNAMIC = 2
|
||||
private const val DT_STRTAB = 5
|
||||
private const val DT_RPATH = 15
|
||||
private const val DT_RUNPATH = 29
|
||||
|
||||
fun read(file: File): List<String> {
|
||||
if (file.length() < 64) return emptyList()
|
||||
RandomAccessFile(file, "r").use { raf ->
|
||||
val channel = raf.channel
|
||||
val header = ByteBuffer.allocate(64).order(ByteOrder.LITTLE_ENDIAN)
|
||||
channel.read(header, 0)
|
||||
if (header.getInt(0) != 0x464c457f || header.get(4).toInt() != 2 || header.get(5).toInt() != 1) return emptyList()
|
||||
val phoff = header.getLong(32)
|
||||
val phentsize = header.getShort(54).toInt() and 0xffff
|
||||
val phnum = header.getShort(56).toInt() and 0xffff
|
||||
if (phnum == 0 || phnum > 128 || phentsize < 56) return emptyList()
|
||||
val table = ByteBuffer.allocate(phentsize * phnum).order(ByteOrder.LITTLE_ENDIAN)
|
||||
channel.read(table, phoff)
|
||||
class Load(val vaddr: Long, val offset: Long, val size: Long)
|
||||
val loads = ArrayList<Load>()
|
||||
var dynOffset = -1L
|
||||
var dynSize = 0L
|
||||
for (i in 0 until phnum) {
|
||||
val at = i * phentsize
|
||||
val type = table.getInt(at)
|
||||
val offset = table.getLong(at + 8)
|
||||
val vaddr = table.getLong(at + 16)
|
||||
val filesz = table.getLong(at + 32)
|
||||
if (type == PT_LOAD) loads.add(Load(vaddr, offset, filesz))
|
||||
if (type == PT_DYNAMIC) { dynOffset = offset; dynSize = filesz }
|
||||
}
|
||||
if (dynOffset < 0 || dynSize <= 0 || dynSize > 1 shl 20) return emptyList()
|
||||
val dynamic = ByteBuffer.allocate(dynSize.toInt()).order(ByteOrder.LITTLE_ENDIAN)
|
||||
channel.read(dynamic, dynOffset)
|
||||
var strtab = -1L
|
||||
val names = ArrayList<Long>()
|
||||
var at = 0
|
||||
while (at + 16 <= dynamic.capacity()) {
|
||||
val tag = dynamic.getLong(at)
|
||||
val value = dynamic.getLong(at + 8)
|
||||
if (tag == 0L) break
|
||||
if (tag == DT_STRTAB.toLong()) strtab = value
|
||||
if (tag == DT_RPATH.toLong() || tag == DT_RUNPATH.toLong()) names.add(value)
|
||||
at += 16
|
||||
}
|
||||
if (strtab < 0 || names.isEmpty()) return emptyList()
|
||||
val strtabOffset = loads.firstOrNull { strtab >= it.vaddr && strtab < it.vaddr + it.size }
|
||||
?.let { strtab - it.vaddr + it.offset } ?: return emptyList()
|
||||
val result = ArrayList<String>()
|
||||
for (name in names) {
|
||||
val buffer = ByteBuffer.allocate(4096)
|
||||
val n = channel.read(buffer, strtabOffset + name)
|
||||
if (n <= 0) continue
|
||||
val bytes = buffer.array()
|
||||
var end = 0
|
||||
while (end < n && bytes[end].toInt() != 0) end++
|
||||
String(bytes, 0, end, Charsets.UTF_8).split(':').filter { it.startsWith("/") }.forEach { result.add(it.trimEnd('/')) }
|
||||
}
|
||||
return result
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
package com.droiddeck.launcher.runtime
|
||||
|
||||
import java.io.File
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
|
||||
/**
|
||||
* Android's app seccomp filter kills a process with SIGSYS for rseq, set_robust_list and clone3. glibc's
|
||||
* dynamic linker makes the first two before any preloaded library (so before the hook's SIGSYS
|
||||
* handler) exists, so the call sites in the rootfs's ld.so and libc answer by themselves instead: the
|
||||
* `svc` after `mov x8, #nr` becomes a no-op for set_robust_list (glibc ignores the result) and
|
||||
* `mov x0, #-ENOSYS` for rseq and clone3 (glibc falls back from both). Under proot the same
|
||||
* answers are what proot gives.
|
||||
*/
|
||||
object ElfSeccompPatch {
|
||||
private const val SVC = 0xd4000001.toInt()
|
||||
private const val NOP = 0xd503201f.toInt()
|
||||
private const val MOV_X0_ENOSYS = 0x928004a0.toInt()
|
||||
private const val MOV_X8_SET_ROBUST_LIST = 0xd2800c68.toInt()
|
||||
private const val MOV_X8_CLONE3 = 0xd2803668.toInt()
|
||||
private const val MOV_X8_RSEQ = 0xd28024a8.toInt()
|
||||
private const val WINDOW = 16
|
||||
|
||||
/** Patches [data] in place and returns the number of call sites changed. */
|
||||
fun patch(data: ByteArray): Int {
|
||||
if (data.size < 64 || data[0] != 0x7f.toByte() || data[1] != 'E'.code.toByte() || data[4].toInt() != 2 || data[5].toInt() != 1) return 0
|
||||
val buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
|
||||
if (buffer.getShort(18).toInt() != 183) return 0
|
||||
val phoff = buffer.getLong(32).toInt()
|
||||
val phentsize = buffer.getShort(54).toInt() and 0xffff
|
||||
val phnum = buffer.getShort(56).toInt() and 0xffff
|
||||
var patched = 0
|
||||
for (i in 0 until phnum) {
|
||||
val at = phoff + i * phentsize
|
||||
if (at + 56 > data.size) break
|
||||
if (buffer.getInt(at) != 1 || (buffer.getInt(at + 4) and 1) == 0) continue
|
||||
val start = ((buffer.getLong(at + 8).toInt()) + 3) and 3.inv()
|
||||
val end = minOf(data.size, buffer.getLong(at + 8).toInt() + buffer.getLong(at + 32).toInt()) and 3.inv()
|
||||
var pos = start
|
||||
while (pos + 4 <= end) {
|
||||
val replacement = when (buffer.getInt(pos)) {
|
||||
MOV_X8_SET_ROBUST_LIST -> NOP
|
||||
MOV_X8_CLONE3, MOV_X8_RSEQ -> MOV_X0_ENOSYS
|
||||
else -> null
|
||||
}
|
||||
if (replacement != null) {
|
||||
var next = pos + 4
|
||||
val limit = minOf(end, pos + 4 + WINDOW * 4)
|
||||
while (next < limit) {
|
||||
val insn = buffer.getInt(next)
|
||||
if (insn == SVC) {
|
||||
buffer.putInt(next, replacement)
|
||||
patched++
|
||||
break
|
||||
}
|
||||
// A site patched before, or x8 set again: an svc after it is another call's
|
||||
// (a second run found clone3's thread exit there and turned it into -ENOSYS)
|
||||
if (insn == MOV_X0_ENOSYS || (insn and 0x1f) == 8) break
|
||||
next += 4
|
||||
}
|
||||
}
|
||||
pos += 4
|
||||
}
|
||||
}
|
||||
return patched
|
||||
}
|
||||
|
||||
/** Patches the file behind [path] (symlinks followed) if it still has unpatched call sites. */
|
||||
fun patchFile(path: File): Int {
|
||||
val target = path.canonicalFile
|
||||
if (!target.isFile) return 0
|
||||
val data = target.readBytes()
|
||||
val count = patch(data)
|
||||
if (count == 0) return 0
|
||||
val temp = File(target.parentFile, "." + target.name + ".seccomp")
|
||||
temp.writeBytes(data)
|
||||
temp.setExecutable(true, false)
|
||||
temp.setReadable(true, false)
|
||||
if (!temp.renameTo(target)) {
|
||||
temp.delete()
|
||||
throw java.io.IOException("could not replace ${target.path}")
|
||||
}
|
||||
return count
|
||||
}
|
||||
}
|
||||
@@ -35,12 +35,10 @@ object GuestCommand {
|
||||
SessionFiles.stage(context, root)
|
||||
LinuxNetworkLinkComponent(context, root).publish()
|
||||
val runtimeDir = File(context.filesDir, ".flatpak-rt").apply { mkdirs() }
|
||||
val cmd = LinuxRuntime.prootPrefix(context, root, "/root", fakeRoot)
|
||||
if (linkDir != null) cmd.add(1, "--link2symlink")
|
||||
val binds = LinuxRuntime.binds(context, null, runtimeDir, Environment.getExternalStorageDirectory(), extraBinds)
|
||||
binds.forEach { cmd.add("-b"); cmd.add(it) }
|
||||
val fastPathKey = if (fastPath && !fakeRoot && linkDir == null && ProotFastPath.enabled(context)) ProotFastPath.key(root, binds) else null
|
||||
cmd += listOf(
|
||||
val native = NativeGuest.forSession(context)
|
||||
val fastPathKey = if (!native && fastPath && !fakeRoot && linkDir == null && ProotFastPath.enabled(context)) ProotFastPath.key(root, binds) else null
|
||||
val guest = mutableListOf(
|
||||
"/usr/bin/env", "-i", "HOME=/root", "USER=root", "LANG=C.UTF-8",
|
||||
"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}",
|
||||
@@ -48,22 +46,31 @@ object GuestCommand {
|
||||
"XDG_DATA_DIRS=/root/.local/share/flatpak/exports/share:/usr/local/share:/usr/share",
|
||||
)
|
||||
DownloadSource.proxyHostPort(context).takeIf { it.isNotEmpty() }?.let { hostPort ->
|
||||
cmd += listOf(
|
||||
guest += listOf(
|
||||
"http_proxy=http://$hostPort", "https_proxy=http://$hostPort",
|
||||
"HTTP_PROXY=http://$hostPort", "HTTPS_PROXY=http://$hostPort",
|
||||
"no_proxy=localhost,127.0.0.1,::1", "NO_PROXY=localhost,127.0.0.1,::1",
|
||||
)
|
||||
}
|
||||
fastPathKey?.let { cmd += ProotFastPath.guestEnv(root, binds, it) }
|
||||
cmd += argv
|
||||
val builder = ProcessBuilder(cmd).directory(root).redirectErrorStream(true)
|
||||
builder.environment().apply {
|
||||
put("PROOT_LOADER", LinuxRuntime.prootLoader(context).path)
|
||||
put("PROOT_TMP_DIR", LinuxRuntime.prootTempDir(context).path)
|
||||
if (linkDir != null) put("PROOT_L2S_DIR", linkDir.path)
|
||||
if (SessionPrefs.prootNoSeccomp(context)) put("PROOT_NO_SECCOMP", "1")
|
||||
fastPathKey?.let { ProotFastPath.hostEnv(it).let { (k, v) -> put(k, v) } }
|
||||
LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) }
|
||||
fastPathKey?.let { guest += ProotFastPath.guestEnv(root, binds, it) }
|
||||
guest += argv
|
||||
val builder = if (native) {
|
||||
NativeGuest.processBuilder(context, root, binds, guest).redirectErrorStream(true)
|
||||
} else {
|
||||
val cmd = LinuxRuntime.prootPrefix(context, root, "/root", fakeRoot)
|
||||
if (linkDir != null) cmd.add(1, "--link2symlink")
|
||||
binds.forEach { cmd.add("-b"); cmd.add(it) }
|
||||
cmd += guest
|
||||
ProcessBuilder(cmd).directory(root).redirectErrorStream(true).also { b ->
|
||||
b.environment().apply {
|
||||
put("PROOT_LOADER", LinuxRuntime.prootLoader(context).path)
|
||||
put("PROOT_TMP_DIR", LinuxRuntime.prootTempDir(context).path)
|
||||
if (linkDir != null) put("PROOT_L2S_DIR", linkDir.path)
|
||||
if (SessionPrefs.prootNoSeccomp(context)) put("PROOT_NO_SECCOMP", "1")
|
||||
fastPathKey?.let { ProotFastPath.hostEnv(it).let { (k, v) -> put(k, v) } }
|
||||
LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) }
|
||||
}
|
||||
}
|
||||
}
|
||||
if (cancelled?.get() == true) return 130
|
||||
val process = builder.start()
|
||||
|
||||
@@ -157,9 +157,7 @@ class LinuxNetworkLinkComponent(
|
||||
synchronized(lock) {
|
||||
try {
|
||||
file.parentFile?.mkdirs()
|
||||
val staged = File(file.path + ".staged")
|
||||
staged.writeText(describe(properties, capabilities))
|
||||
if (!staged.renameTo(file)) throw IOException("Could not replace $file")
|
||||
replace(file, describe(properties, capabilities))
|
||||
} catch (e: IOException) {
|
||||
Log.w(TAG, "Could not publish the network link", e)
|
||||
}
|
||||
@@ -241,9 +239,7 @@ class LinuxNetworkLinkComponent(
|
||||
}
|
||||
try {
|
||||
val file = File(rootDir, "etc/droiddeck-network.json")
|
||||
val staged = File(file.path + ".staged")
|
||||
staged.writeText(state.toString())
|
||||
if (!staged.renameTo(file)) throw IOException("Could not replace network state")
|
||||
replace(file, state.toString())
|
||||
} catch (e: IOException) {
|
||||
Log.w(TAG, "Could not publish the network state", e)
|
||||
}
|
||||
@@ -272,6 +268,19 @@ class LinuxNetworkLinkComponent(
|
||||
return Pair(servers.sortedWith(order), gateways.sortedWith(order))
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes [text] to [file] through a staged copy. The copy is synced before the rename, or a
|
||||
* crash or power cut can keep the rename and lose the data, leaving a file of NUL bytes.
|
||||
*/
|
||||
private fun replace(file: File, text: String) {
|
||||
val staged = File(file.path + ".staged")
|
||||
java.io.FileOutputStream(staged).use { out ->
|
||||
out.write(text.toByteArray())
|
||||
out.fd.sync()
|
||||
}
|
||||
if (!staged.renameTo(file)) throw IOException("Could not replace $file")
|
||||
}
|
||||
|
||||
private fun writeResolver(properties: LinkProperties?) {
|
||||
val own = properties?.dnsServers.orEmpty()
|
||||
.filter { !it.isLinkLocalAddress && !it.isLoopbackAddress && !it.isAnyLocalAddress }
|
||||
@@ -286,9 +295,7 @@ class LinuxNetworkLinkComponent(
|
||||
}
|
||||
try {
|
||||
val etc = File(rootDir, "etc")
|
||||
val staged = File(etc, "resolv.conf.staged")
|
||||
staged.writeText(text)
|
||||
if (!staged.renameTo(File(etc, "resolv.conf"))) throw IOException("Could not replace resolv.conf")
|
||||
replace(File(etc, "resolv.conf"), text)
|
||||
val hosts = File(etc, "hosts")
|
||||
if (!hosts.isFile || !hosts.readText().contains("localhost")) {
|
||||
hosts.writeText("127.0.0.1 localhost\n::1 localhost\n")
|
||||
|
||||
@@ -139,15 +139,26 @@ public final class LinuxRuntime {
|
||||
public static List<String> command(Context context, File sessionRoot, File runtimeDir,
|
||||
File externalStorage, List<String> extraBinds,
|
||||
List<String> guestCommand) {
|
||||
return command(context, sessionRoot, runtimeDir, externalStorage, extraBinds, guestCommand, false);
|
||||
}
|
||||
|
||||
public static List<String> command(Context context, File sessionRoot, File runtimeDir,
|
||||
File externalStorage, List<String> extraBinds,
|
||||
List<String> guestCommand, boolean fakeRoot) {
|
||||
File root = rootDir(context);
|
||||
List<String> binds = binds(context, sessionRoot, runtimeDir, externalStorage, extraBinds);
|
||||
if (sessionRoot != null) lastBinds = binds;
|
||||
return commandWithBinds(context, root, binds, guestCommand);
|
||||
return commandWithBinds(context, root, binds, guestCommand, fakeRoot);
|
||||
}
|
||||
|
||||
public static List<String> commandWithBinds(Context context, File root, List<String> binds,
|
||||
List<String> guestCommand) {
|
||||
List<String> cmd = prootPrefix(context, root, "/root");
|
||||
return commandWithBinds(context, root, binds, guestCommand, false);
|
||||
}
|
||||
|
||||
public static List<String> commandWithBinds(Context context, File root, List<String> binds,
|
||||
List<String> guestCommand, boolean fakeRoot) {
|
||||
List<String> cmd = fakeRoot ? rootPrefix(context, root, "/root") : prootPrefix(context, root, "/root");
|
||||
for (String spec : binds) bind(cmd, spec);
|
||||
cmd.addAll(guestCommand);
|
||||
return cmd;
|
||||
@@ -155,6 +166,11 @@ public final class LinuxRuntime {
|
||||
|
||||
private static volatile List<String> lastBinds;
|
||||
|
||||
/** The mounts of a session started without proot, which sandboxes and root helpers see too. */
|
||||
public static void rememberSessionBinds(List<String> binds) {
|
||||
lastBinds = binds;
|
||||
}
|
||||
|
||||
public static List<String> lastBinds(Context context) {
|
||||
List<String> binds = lastBinds;
|
||||
if (binds != null) return binds;
|
||||
@@ -165,6 +181,12 @@ public final class LinuxRuntime {
|
||||
return prootPrefix(context, root, cwd, false);
|
||||
}
|
||||
|
||||
public static List<String> rootPrefix(Context context, File root, String cwd) {
|
||||
List<String> cmd = prootPrefix(context, root, cwd, true);
|
||||
cmd.add(1, "--link2symlink");
|
||||
return cmd;
|
||||
}
|
||||
|
||||
public static List<String> prootPrefix(Context context, File root, String cwd, boolean fakeRoot) {
|
||||
List<String> cmd = new ArrayList<>();
|
||||
cmd.add(prootBinary(context).getPath());
|
||||
@@ -306,7 +328,17 @@ public final class LinuxRuntime {
|
||||
|
||||
private static boolean unreadablePciDevice() {
|
||||
File[] devices = new File("/sys/bus/pci/devices").listFiles();
|
||||
if (devices == null) return false;
|
||||
if (devices == null) {
|
||||
// The directory is there but the app may not list it (Android 13 on the AYN Thor): libpci then
|
||||
// aborts the whole program with "Cannot open /sys/bus/pci/devices", which Chromium's GPU
|
||||
// initialisation runs into. Not there at all (no PCI bus) is fine as it is.
|
||||
try {
|
||||
android.system.Os.stat("/sys/bus/pci/devices");
|
||||
return true;
|
||||
} catch (android.system.ErrnoException e) {
|
||||
return e.errno == android.system.OsConstants.EACCES;
|
||||
}
|
||||
}
|
||||
for (File device : devices) {
|
||||
if (!new File(device, "vendor").canRead()) return true;
|
||||
}
|
||||
|
||||
Loaded 100 of 667 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user