ADFA-5659: shut the Gradle daemon watcher down with the server

subprojects/tooling-api-impl/src/main/java/com/itsaky/androidide/tooling/impl/GradleDaemonWatcher.kt

@@ -124,8 +124,29 @@ internal class GradleDaemonWatcher(
 			.onFailure { err -> log.warn("Failed to report exit of Gradle daemon {}", pid, err) }
 	}
 
+	/**
+	 * Stops the poller.
+	 *
+	 * Graceful first, so a report already queued -- an exit picked up moments before the server was
+	 * told to stop -- still runs; then forcefully, so a poll asleep between attempts cannot hold the
+	 * process open. [SHUTDOWN_GRACE_MS] is the bound: work is one `ProcessHandle.descendants()`
+	 * scan, not a build, so a poll that has not finished in that long is wedged rather than busy.
+	 *
+	 * A report that has *not* been submitted yet is lost, and that is accepted: it arrives via
+	 * onExit on a process-reaper thread once the OS reaps the daemon, which at shutdown is after
+	 * everything here has run.
+	 */
 	fun shutdown() {
-		scheduler.shutdownNow()
+		scheduler.shutdown()
+		val drained =
+			runCatching { scheduler.awaitTermination(SHUTDOWN_GRACE_MS, TimeUnit.MILLISECONDS) }
+				.getOrElse {
+					Thread.currentThread().interrupt()
+					false
+				}
+		if (!drained) {
+			scheduler.shutdownNow()
+		}
 	}
 
 	companion object {
@@ -143,6 +164,9 @@ internal class GradleDaemonWatcher(
 
 		private const val POLL_INTERVAL_MS = 500L
 
+		/** How long [shutdown] lets queued reports finish before it stops waiting. */
+		const val SHUTDOWN_GRACE_MS = 250L
+
 		/** Bounded at roughly a minute, which is far longer than a daemon takes to come up. */
 		const val MAX_POLL_ATTEMPTS = 120
 

subprojects/tooling-api-impl/src/main/java/com/itsaky/androidide/tooling/impl/ToolingApiServerImpl.kt

@@ -73,7 +73,10 @@ import kotlin.concurrent.withLock
  *
  * @author Akash Yadav
  */
-internal class ToolingApiServerImpl : IToolingApiServer {
+internal class ToolingApiServerImpl(
+	private val newDaemonWatcher: (onStarted: (Int) -> Unit, onExited: (Int) -> Unit) -> GradleDaemonWatcher =
+		{ onStarted, onExited -> GradleDaemonWatcher(onStarted = onStarted, onExited = onExited) },
+) : IToolingApiServer {
 	private var client: IToolingApiClient? = null
 	private var connector: GradleConnector? = null
 	private var connection: ProjectConnection? = null
@@ -361,12 +364,15 @@ internal class ToolingApiServerImpl : IToolingApiServer {
 	 * Finds the Gradle daemon and reports it to the client, so the memory chart can plot the process
 	 * that actually holds the build's heap (ADFA-5514).
 	 */
-	private val daemonWatcher by lazy {
-		GradleDaemonWatcher(
-			onStarted = { pid -> client?.onGradleDaemonStarted(pid) },
-			onExited = { pid -> client?.onGradleDaemonExited(pid) },
-		)
-	}
+	private val lazyDaemonWatcher =
+		lazy {
+			newDaemonWatcher(
+				{ pid -> client?.onGradleDaemonStarted(pid) },
+				{ pid -> client?.onGradleDaemonExited(pid) },
+			)
+		}
+
+	private val daemonWatcher by lazyDaemonWatcher
 
 	private fun notifyBuildFailure(result: BuildResult) {
 		client?.onBuildFailed(result)
@@ -407,6 +413,31 @@ internal class ToolingApiServerImpl : IToolingApiServer {
 			buildCancellationToken?.cancel()
 			buildCancellationToken = null
 
+			// Early, and deliberately not "late enough to report the daemon's exit".
+			//
+			// The leaked thread is the defect: unstopped, an in-flight poll chain goes on scanning
+			// ProcessHandle.descendants() for up to a minute after the server is gone. Stopping it
+			// here ends that at once, and means no later poll can report a daemon into an RPC
+			// channel that is being torn down.
+			//
+			// Delivering the shutdown-time exit was tried and does not work. That report arrives
+			// through handle.onExit().thenRun { scheduler.execute { ... } }, and onExit completes
+			// on a process-reaper thread only once the OS has reaped the daemon -- strictly after
+			// DefaultGradleConnector.close() returns. There is no point in this sequence where the
+			// scheduler is still accepting work *and* the daemon has already been reaped, so the
+			// report is not deliverable at shutdown whatever the ordering; keeping `client` alive
+			// for it only widens the window in which a half-torn-down channel can be written to.
+			// The client learns the daemon is gone when it reconnects, not from here.
+			//
+			// Through the lazy delegate rather than the property: touching the property would
+			// construct a watcher, and its scheduler, only to shut it down again on a server that
+			// never ran a build.
+			if (lazyDaemonWatcher.isInitialized()) {
+				log.info("Stopping the Gradle daemon watcher...")
+				runCatching { daemonWatcher.shutdown() }
+					.onFailure { log.warn("Could not stop the Gradle daemon watcher", it) }
+			}
+
 			val connection = this.connection
 			val connector = this.connector
 			this.connection = null

subprojects/tooling-api-impl/src/test/java/com/itsaky/androidide/tooling/impl/GradleDaemonWatcherTest.kt

@@ -213,4 +213,28 @@ class GradleDaemonWatcherTest {
 		/** Every poll attempt, plus the initial schedule. */
 		const val MAX_SCHEDULES = GradleDaemonWatcher.MAX_POLL_ATTEMPTS + 1
 	}
+
+	@Test
+	fun `shutdown drains what is queued before it stops waiting`() {
+		// Graceful first: a report queued moments before the server was told to stop still runs.
+		val scheduler = mockk<ScheduledExecutorService>(relaxed = true)
+		every { scheduler.awaitTermination(any(), any()) } returns true
+
+		watcher(scheduler = scheduler).shutdown()
+
+		verify(exactly = 1) { scheduler.shutdown() }
+		verify(exactly = 1) { scheduler.awaitTermination(GradleDaemonWatcher.SHUTDOWN_GRACE_MS, TimeUnit.MILLISECONDS) }
+		verify(exactly = 0) { scheduler.shutdownNow() }
+	}
+
+	@Test
+	fun `shutdown stops waiting on a poll that will not finish`() {
+		// And forcefully after the grace period, so a wedged scan cannot hold the process open.
+		val scheduler = mockk<ScheduledExecutorService>(relaxed = true)
+		every { scheduler.awaitTermination(any(), any()) } returns false
+
+		watcher(scheduler = scheduler).shutdown()
+
+		verify(exactly = 1) { scheduler.shutdownNow() }
+	}
 }

subprojects/tooling-api-impl/src/test/java/com/itsaky/androidide/tooling/impl/ToolingApiServerImplTest.kt

@@ -124,4 +124,39 @@ class ToolingApiServerImplTest {
 			RootModelBuilder.build(initParams, any())
 		}
 	}
+
+	@Test
+	fun `shutting the server down stops the daemon watcher`() {
+		// The defect this PR exists to fix, pinned at the caller. The watcher's own shutdown() was
+		// already correct on stage -- what was missing was anything calling it, so a test of
+		// GradleDaemonWatcher.shutdown() in isolation passes against the unfixed server and pins
+		// nothing. Deleting the block in ToolingApiServerImpl.shutdown() has to fail a test.
+		val watcher = mockk<GradleDaemonWatcher>(relaxed = true)
+		val server = ToolingApiServerImpl(newDaemonWatcher = { _, _ -> watcher })
+
+		// A build, to bring the watcher into being the way a session does: runBuild calls
+		// onBuildStarted, which is what initializes the lazy.
+		server.initialize(testInitParams()).get(5, TimeUnit.SECONDS)
+		server.shutdown().get(5, TimeUnit.SECONDS)
+
+		verify(exactly = 1) { watcher.shutdown() }
+	}
+
+	@Test
+	fun `a server that never ran a build does not build a watcher just to stop it`() {
+		// Through the lazy delegate, not the property: touching the property would construct a
+		// watcher, and its scheduler thread, only to shut it down again.
+		var built = 0
+		val server =
+			ToolingApiServerImpl(
+				newDaemonWatcher = { _, _ ->
+					built++
+					mockk(relaxed = true)
+				},
+			)
+
+		server.shutdown().get(5, TimeUnit.SECONDS)
+
+		assertThat(built).isEqualTo(0)
+	}
 }