fix: let the device sleep while a session is suspended (#1220)

* fix: stop the DirectAudio output while the sink is suspended

* fix: verify every session thread before reporting suspension

* fix: freeze PRoot first and stop each guest thread on suspend

---------

Co-authored-by: Detinator10 <8469261+Detinator10@users.noreply.github.com>
This commit is contained in:
Kurt HimebauchandDetinator10 authored and GitHub committed 2026-10-20 16:43:09 -04:00
1 parent 8ea48dc039
commit 4f8a7c5596
5 files changed
+611 -111

No files matched your search

@@ -0,0 +1,379 @@
package com.droiddeck.launcher.session
import java.io.File
import java.util.concurrent.AbstractExecutorService
import java.util.concurrent.RejectedExecutionException
import java.util.concurrent.TimeUnit
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Rule
import org.junit.Test
import org.junit.rules.TemporaryFolder
class SessionSuspendControllerTest {
@get:Rule val temporary = TemporaryFolder()
@Test fun everyWorkerThreadIsStoppedAfterTheRoot() {
for (count in listOf(17, 68)) {
val fixture = fixture(count)
fixture.controller.freeze { assertTrue(it) }
assertTrue(fixture.game.threads.all { it.state == 't' })
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= count)
assertEquals(ROOT, fixture.signals.first { it.signal == STOP }.pid)
assertTrue(fixture.now < 1000)
assertEquals(1, fixture.audioSuspends)
}
}
@Test fun cpuMustBeStableAcrossTwoCompleteSnapshots() {
val fixture = fixture(17)
var changes = 0
fixture.afterSleep = {
if (fixture.game.threads.all { it.state == 't' } && changes < 3) {
fixture.game.threads.last().cpu++
changes++
}
}
fixture.controller.freeze { assertTrue(it) }
assertEquals(3, changes)
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= 17)
}
@Test fun reusedTidAndNewThreadMustJoinTheStableInventory() {
val fixture = fixture(17)
var changed = false
fixture.afterSleep = {
if (!changed && fixture.game.threads.all { it.state == 't' }) {
changed = true
fixture.game.threads.last().apply { started++; state = 'S'; cpu = 0 }
fixture.game.threads += Task(500, 9000, 'S')
}
}
fixture.controller.freeze { assertTrue(it) }
assertTrue(changed)
assertTrue(fixture.game.threads.all { it.state == 't' })
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= 19)
}
@Test fun zombieLeaderDoesNotHideRunningWorkers() {
val fixture = fixture(17)
fixture.game.threads.first().state = 'Z'
fixture.sync()
fixture.controller.freeze { assertTrue(it) }
assertEquals('Z', fixture.game.threads.first().state)
assertTrue(fixture.game.threads.drop(1).all { it.state == 't' })
assertTrue(fixture.signals.count { it.pid == GAME && it.signal == STOP } >= 16)
}
@Test fun lateReparentedTraceeIsDiscoveredAndResumed() {
val fixture = fixture(17)
val late = Group(600, 1, ROOT, mutableListOf(Task(600, 6000, 'S')))
fixture.afterSleep = {
if (fixture.root.threads.first().state == 'T' && late !in fixture.groups) fixture.groups += late
}
fixture.controller.freeze { assertTrue(it) }
assertEquals('t', late.threads.first().state)
fixture.controller.resume { assertTrue(it) }
assertEquals('S', late.threads.first().state)
}
@Test fun descendantHelperKeepsRootStopAndResumeOrdering() {
val fixture = fixture(17)
val helper = Group(700, ROOT, 0, mutableListOf(Task(700, 7000, 'S')))
fixture.groups += helper
fixture.helpers += helper.pid
fixture.sync()
fixture.controller.freeze { assertTrue(it) }
val stops = fixture.signals.filter { it.signal == STOP }
assertTrue(stops.indexOfFirst { it.pid == ROOT } < stops.indexOfFirst { it.pid == helper.pid })
val before = fixture.signals.size
fixture.controller.resume { assertTrue(it) }
assertEquals(listOf(ROOT, helper.pid, GAME), fixture.signals.drop(before).take(3).map { it.pid })
}
@Test fun retainedHelperDoesNotAdoptAReusedPidOnRefreeze() {
val fixture = fixture(17)
val helper = Group(700, 9000, 0, mutableListOf(Task(700, 7000, 'S')))
fixture.groups += helper
fixture.helpers += helper.pid
fixture.sync()
fixture.controller.freeze { assertTrue(it) }
fixture.blockGameContinue = true
fixture.controller.resume { assertFalse(it) }
helper.threads.first().apply { started++; state = 'S' }
fixture.sync()
val before = fixture.signals.size
fixture.controller.freeze { assertTrue(it) }
assertFalse(fixture.signals.drop(before).any { it.pid == helper.pid })
}
@Test fun timeoutRollsBackAllKnownProcessesAndAudio() {
val fixture = fixture(17)
fixture.neverStop = true
fixture.controller.freeze { assertFalse(it) }
assertTrue(fixture.now <= 8100)
assertEquals(ROOT, fixture.signals.first { it.signal == CONT }.pid)
assertTrue(fixture.game.threads.all { it.state == 'S' })
assertEquals(1, fixture.audioResumes)
}
@Test fun missingKnownStatCannotBeMistakenForAnExitedProcess() {
val fixture = fixture(17)
fixture.afterSleep = {
if (fixture.root.threads.first().state == 'T') fixture.missingGameStat = true
}
fixture.controller.freeze { assertFalse(it) }
assertEquals(1, fixture.audioResumes)
fixture.missingGameStat = false
fixture.sync()
fixture.controller.resume { assertTrue(it) }
assertTrue(fixture.game.threads.all { it.state == 'S' })
}
@Test fun unavailableOrEmptyThreadInventoryCannotReportSuccess() {
for (empty in listOf(false, true)) {
val fixture = fixture(17)
fixture.emptyGameTasks = empty
fixture.missingGameTasks = !empty
fixture.sync()
fixture.controller.freeze { assertFalse(it) }
assertEquals(1, fixture.audioResumes)
assertTrue(fixture.game.threads.all { it.state == 'S' })
}
}
@Test fun disappearingRootFailsAndStillResumesKnownChildren() {
val fixture = fixture(17)
fixture.afterSleep = {
if (fixture.root.threads.first().state == 'T') fixture.rootGone = true
}
fixture.controller.freeze { assertFalse(it) }
assertTrue(fixture.game.threads.all { it.state == 'S' })
assertEquals(1, fixture.audioResumes)
}
@Test fun replacementRootIsNeverStoppedOrContinued() {
val fixture = fixture(17)
var atReplacement = -1
fixture.afterSleep = {
if (atReplacement < 0 && fixture.root.threads.first().state == 'T') {
atReplacement = fixture.signals.size
fixture.root.threads.first().apply { started++; state = 'S' }
}
}
fixture.controller.freeze { assertFalse(it) }
assertTrue(atReplacement > 0)
assertFalse(fixture.signals.drop(atReplacement).any { it.pid == ROOT })
assertTrue(fixture.game.threads.all { it.state == 'S' })
}
@Test fun reusedChildPidIsNotContinuedDuringResume() {
val fixture = fixture(17)
fixture.controller.freeze { assertTrue(it) }
fixture.game.threads.first().apply { started++; state = 'S' }
fixture.game.parent = 1
fixture.game.tracer = 0
fixture.sync()
val before = fixture.signals.size
fixture.controller.resume { assertTrue(it) }
assertFalse(fixture.signals.drop(before).any { it.pid == GAME })
}
@Test fun closeCancelsFreezeAndRestoresSavedRootAfterServiceClearsIt() {
val executor = QueueExecutor()
val fixture = fixture(68, executor)
var closed = false
var requested = false
fixture.afterSleep = {
if (!requested && fixture.root.threads.first().state == 'T') {
requested = true
fixture.rootPid = -1
fixture.controller.closeAndResume { closed = true }
}
}
fixture.controller.freeze { assertFalse(it) }
executor.drain()
assertTrue(closed)
assertTrue(executor.isShutdown)
assertTrue(fixture.game.threads.all { it.state == 'S' })
assertEquals(1, fixture.audioResumes)
}
@Test fun successfulFreezeIsRecheckedAndAudioIsReassertedAfterFailedResume() {
val fixture = fixture(17)
fixture.controller.freeze { assertTrue(it) }
fixture.blockGameContinue = true
fixture.controller.resume { assertFalse(it) }
assertEquals(1, fixture.audioResumes)
fixture.blockGameContinue = false
fixture.game.threads.last().state = 'S'
fixture.sync()
fixture.controller.freeze { assertTrue(it) }
assertTrue(fixture.game.threads.all { it.state == 't' })
assertEquals(2, fixture.audioSuspends)
}
@Test fun failedRollbackCanBeRefrozenAndAudioIsSuspendedAgain() {
val fixture = fixture(17)
fixture.neverStop = true
fixture.blockGameContinue = true
fixture.controller.freeze { assertFalse(it) }
fixture.neverStop = false
fixture.blockGameContinue = false
fixture.controller.freeze { assertTrue(it) }
assertTrue(fixture.game.threads.all { it.state == 't' })
assertEquals(2, fixture.audioSuspends)
assertEquals(1, fixture.audioResumes)
}
@Test fun repeatedFreezeResumeKeepsOriginalRootFirstOrdering() {
val fixture = fixture(17)
repeat(2) {
fixture.controller.freeze { assertTrue(it) }
val before = fixture.signals.size
fixture.controller.resume { assertTrue(it) }
assertEquals(ROOT, fixture.signals.drop(before).first().pid)
assertTrue(fixture.game.threads.all { it.state == 'S' })
}
fixture.controller.freeze { assertTrue(it) }
fixture.rootPid = -1
var closed = false
fixture.controller.closeAndResume { closed = true }
assertTrue(closed)
assertTrue(fixture.game.threads.all { it.state == 'S' })
}
@Test fun rejectedExecutorDoesNotFreezeOnTheCallingThread() {
val executor = QueueExecutor().apply { shutdown() }
val fixture = fixture(17, executor)
fixture.controller.freeze { assertFalse(it) }
assertTrue(fixture.signals.isEmpty())
assertEquals(0, fixture.audioSuspends)
}
private fun fixture(count: Int, executor: QueueExecutor = InlineExecutor()) =
Fixture(temporary.newFolder(), count, executor)
private data class Task(val tid: Int, var started: Long, var state: Char, var cpu: Long = 0)
private data class Group(val pid: Int, var parent: Int, var tracer: Int, val threads: MutableList<Task>)
private data class SentSignal(val pid: Int, val signal: Int)
private class Fixture(val proc: File, count: Int, executor: QueueExecutor) {
val root = Group(ROOT, 9000, 0, mutableListOf(Task(ROOT, 1000, 'S')))
val game = Group(GAME, ROOT, ROOT, MutableList(count) { Task(GAME + it, 2000L + it, 'S') })
val groups = mutableListOf(root, game)
val helpers = mutableListOf<Int>()
val signals = mutableListOf<SentSignal>()
var rootPid = ROOT
var now = 0L
var audioSuspends = 0
var audioResumes = 0
var neverStop = false
var blockGameContinue = false
var missingGameStat = false
var missingGameTasks = false
var emptyGameTasks = false
var rootGone = false
var afterSleep: (() -> Unit)? = null
private var continuing = false
val controller = SessionSuspendController(
{ rootPid }, { helpers }, { audioSuspends++ }, { audioResumes++ },
proc, ::signal, ::threadSignal, ::sleep, { now }, executor,
)
init { sync() }
private fun signal(pid: Int, signal: Int) {
signals += SentSignal(pid, signal)
val group = groups.first { it.pid == pid }
if (signal == STOP) {
continuing = false
if (pid == ROOT) group.threads.forEach { it.state = 'T' }
else group.threads.firstOrNull {
it.state !in listOf('T', 't', 'Z', 'X') && !(neverStop && it == game.threads.last())
}?.state = 't'
} else if (signal == CONT) {
continuing = true
if (!(pid == GAME && blockGameContinue)) group.threads.forEach { if (it.state != 'Z') it.state = 'S' }
}
sync()
}
private fun threadSignal(pid: Int, tid: Int, signal: Int) {
signals += SentSignal(pid, signal)
val task = groups.first { it.pid == pid }.threads.first { it.tid == tid }
if (signal == STOP && task.state !in listOf('T', 't', 'Z', 'X') && !(neverStop && task == game.threads.last())) {
task.state = 't'
}
sync()
}
private fun sleep(millis: Long) {
now += millis
if (root.threads.first().state != 'T' && !continuing) game.threads.forEach {
if (it.state != 'Z') { it.state = 'S'; it.cpu++ }
}
afterSleep?.invoke()
sync()
}
fun sync() {
for (group in groups) {
val dir = File(proc, group.pid.toString())
if (group == root && rootGone) { dir.deleteRecursively(); continue }
dir.mkdirs()
val stat = File(dir, "stat")
if (group == game && missingGameStat) stat.delete()
else stat.writeText(stat(group, group.threads.first()))
File(dir, "status").writeText("TracerPid: ${group.tracer}\n")
val taskDir = File(dir, "task")
if (group == game && missingGameTasks) { taskDir.deleteRecursively(); continue }
taskDir.mkdirs()
if (group == game && emptyGameTasks) { taskDir.listFiles().orEmpty().forEach { it.deleteRecursively() }; continue }
for (task in group.threads) {
val entry = File(taskDir, task.tid.toString()).apply { mkdirs() }
File(entry, "stat").writeText(stat(group, task))
}
}
}
private fun stat(group: Group, task: Task): String {
val fields = MutableList(20) { "0" }
fields[0] = task.state.toString()
fields[1] = group.parent.toString()
fields[11] = task.cpu.toString()
fields[19] = task.started.toString()
return "${task.tid} (fixture (worker)) ${fields.joinToString(" ")}"
}
}
private open class QueueExecutor : AbstractExecutorService() {
private val queue = ArrayDeque<Runnable>()
private var stopped = false
override fun execute(command: Runnable) {
if (stopped) throw RejectedExecutionException()
queue.add(command)
}
fun drain() { while (queue.isNotEmpty()) queue.removeFirst().run() }
override fun shutdown() { stopped = true }
override fun shutdownNow(): MutableList<Runnable> {
stopped = true
return queue.toMutableList().also { queue.clear() }
}
override fun isShutdown() = stopped
override fun isTerminated() = stopped && queue.isEmpty()
override fun awaitTermination(timeout: Long, unit: TimeUnit) = isTerminated
}
private class InlineExecutor : QueueExecutor() {
override fun execute(command: Runnable) { super.execute(command); drain() }
}
private companion object {
const val ROOT = 100
const val GAME = 200
const val STOP = 19
const val CONT = 18
}
}