ADFA-2308: force-stop tooling server upon shutdown

app/src/main/java/com/itsaky/androidide/app/IDEApplication.kt

@@ -33,7 +33,10 @@ import com.itsaky.androidide.utils.isAtLeastR
 import com.itsaky.androidide.utils.isTestMode
 import com.topjohnwu.superuser.Shell
 import io.sentry.Sentry
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.plus
 import org.lsposed.hiddenapibypass.HiddenApiBypass
 import org.slf4j.LoggerFactory
 import java.lang.Thread.UncaughtExceptionHandler
@@ -42,6 +45,8 @@ const val EXIT_CODE_CRASH = 1
 
 class IDEApplication : BaseApplication() {
 
+	val coroutineScope = MainScope() + CoroutineName("ApplicationScope")
+
 	internal var uncaughtExceptionHandler: UncaughtExceptionHandler? = null
 	private var currentActivity: Activity? = null
 

app/src/main/java/com/itsaky/androidide/services/builder/GradleBuildService.kt

@@ -30,6 +30,7 @@ import com.blankj.utilcode.util.ZipUtils
 import com.itsaky.androidide.BuildConfig
 import com.itsaky.androidide.analytics.IAnalyticsManager
 import com.itsaky.androidide.app.BaseApplication
+import com.itsaky.androidide.app.IDEApplication
 import com.itsaky.androidide.lookup.Lookup
 import com.itsaky.androidide.managers.ToolsManager
 import com.itsaky.androidide.preferences.internal.BuildPreferences
@@ -63,6 +64,8 @@ import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.future.await
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import org.koin.android.ext.android.inject
 import org.slf4j.LoggerFactory
@@ -72,8 +75,8 @@ import java.io.InputStream
 import java.util.Objects
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.CompletionException
-import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
+import kotlin.coroutines.cancellation.CancellationException
 
 /**
  * A foreground service that handles interaction with the Gradle Tooling API.
@@ -235,7 +238,9 @@ class GradleBuildService :
  // send the shutdown request but do not wait for the server to respond
  // the service should not block the onDestroy call in order to avoid timeouts
  // the tooling server must release resources and exit automatically
- server.shutdown().get(1, TimeUnit.SECONDS)
+ IDEApplication.instance.coroutineScope.launch(Dispatchers.IO) {
+ server.shutdown().await()
+ }
  } catch (e: Throwable) {
  if (e !is TimeoutException) {
  log.error("Failed to shutdown Tooling API server", e)
@@ -640,6 +645,7 @@ class GradleBuildService :
  try {
  reader.forEachLine { line ->
  SERVER_System_err.error(line)
+ if (!isActive) throw CancellationException()
  }
  } catch (e: Throwable) {
  e.ifCancelledOrInterrupted(suppress = true) {

app/src/main/java/com/itsaky/androidide/services/builder/ToolingServerRunner.kt

@@ -170,7 +170,6 @@ internal class ToolingServerRunner(
  }
  }
 
- processJob.join()
  joinAll(serverJob, processJob)
  } catch (e: Throwable) {
  if (e !is CancellationException) {

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

@@ -25,14 +25,14 @@ import java.io.OutputStream
  * @author Akash Yadav
  */
 class LoggingOutputStream : OutputStream() {
-private val lineBuilder = StringBuilder()
-override fun write(b: Int) {
-val c = b.toChar()
-lineBuilder.append(c)
+private val lineBuilder = StringBuilder()
+override fun write(b: Int) {
+val c = b.toChar()
+lineBuilder.append(c)
 
-if (c == '\n' && Main.client != null) {
-Main.client.logOutput(lineBuilder.toString())
-lineBuilder.clear()
-}
-}
+if (c == '\n' && Main.client != null) {
+Main.client?.logOutput(lineBuilder.toString())
+lineBuilder.clear()
+}
+}
 }

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

@@ -0,0 +1,122 @@
+/*
+ * This file is part of AndroidIDE.
+ *
+ * AndroidIDE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * AndroidIDE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with AndroidIDE. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.itsaky.androidide.tooling.impl
+
+import com.itsaky.androidide.tooling.api.IToolingApiClient
+import com.itsaky.androidide.tooling.api.util.ToolingApiLauncher.newServerLauncher
+import org.gradle.tooling.events.OperationType
+import org.slf4j.LoggerFactory
+import java.util.concurrent.CancellationException
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
+import kotlin.system.exitProcess
+
+object Main {
+	private val logger = LoggerFactory.getLogger(Main::class.java)
+
+	@Volatile
+	private var _client: IToolingApiClient? = null
+
+	@Volatile
+	private var _future: Future<Void?>? = null
+
+	val client: IToolingApiClient?
+ get() = _client
+
+	val future: Future<Void?>?
+ get() = _future
+
+	fun checkGradleWrapper() {
+ logger.info("Checking gradle wrapper availability...")
+ try {
+ if (client?.checkGradleWrapperAvailability()?.get()?.isAvailable != true) {
+ logger.warn(
+ ("Gradle wrapper is not available."
+ + " Client might have failed to ensure availability."
+ + " Build might fail.")
+ )
+ } else {
+ logger.info("Gradle wrapper is available")
+ }
+ } catch (e: Throwable) {
+ logger.warn("Unable to get Gradle wrapper availability from client", e)
+ }
+	}
+
+	@JvmStatic
+	fun main(args: Array<String>) {
+ logger.debug("Starting Tooling API server...")
+
+ val server = ToolingApiServerImpl()
+ val executorService = Executors.newCachedThreadPool()
+ val launcher = newServerLauncher(server, System.`in`, System.out, executorService)
+
+ val future = launcher.startListening()
+ val client = launcher.getRemoteProxy() as? IToolingApiClient
+ ?: error("Failed to get IToolingApiClient proxy from launcher")
+
+ _client = client
+ _future = future
+
+ server.connect(client)
+
+ logger.debug("Server started. Will run until shutdown message is received...")
+ logger.debug("Running on Java version: {}", System.getProperty("java.version", "<unknown>"))
+
+ try {
+ future.get()
+ } catch (_: CancellationException) {
+ // ignored
+ } catch (e: InterruptedException) {
+ logger.error("Main thread interrupted while waiting for shutdown message", e)
+ Thread.currentThread().interrupt()
+ } catch (e: ExecutionException) {
+ logger.error("An error occurred while waiting for shutdown message", e)
+ } finally {
+ // Cleanup should be performed in ToolingApiServerImpl.shutdown()
+ // this is to make sure that the daemons are stopped in case the client doesn't call shutdown()
+ try {
+ if (server.isInitialized || server.isConnected) {
+ logger.warn("Connection to tooling server closed without shutting it down!")
+ server.shutdown().get()
+ }
+
+ executorService.shutdownNow()
+ } catch (e: InterruptedException) {
+ logger.error("Main thread interrupted while shutting down tooling API server", e)
+ Thread.currentThread().interrupt()
+ } catch (e: Throwable) {
+ logger.error("An error occurred while shutting down tooling API server", e)
+ } finally {
+ _client = null
+ _future = null
+
+ runCatching {
+ future.cancel(true)
+ }.onFailure { error ->
+ logger.error("Failed to cancel launcher future", error)
+ }
+
+ logger.info("Tooling API server shutdown complete")
+ exitProcess(0)
+ }
+ }
+	}
+
+	fun progressUpdateTypes() = setOf(OperationType.TASK, OperationType.PROJECT_CONFIGURATION)
+}

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

@@ -363,14 +363,14 @@ internal class ToolingApiServerImpl : IToolingApiServer {
 
  // cancelling this future will finish the Tooling API server process
  // see com.itsaky.androidide.tooling.impl.Main.main(String[])
+ log.info("Cancelling awaiting future...")
  Main.future?.cancel(true)
 
  this.client = null
  this.buildCancellationToken = null // connector.disconnect() cancels any running builds
  this.lastInitParams = null
- Main.future = null
- Main.client = null
 
+ log.info("Shutdown request completed.")
  null
  }
 

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

@@ -103,6 +103,6 @@ class ForwardingProgressListener : ProgressListener {
  }
  }
 
- Main.client.onProgressEvent(ideEvent)
+ Main.client?.onProgressEvent(ideEvent)
  }
 }

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

@@ -214,9 +214,7 @@ object RootModelBuilder :
  val logger = LoggerFactory.getLogger("RootModelBuilder")
  logger.warn("Starting build. See build output for more details...")
 
- if (Main.client != null) {
- Main.client.logOutput("Starting build...")
- }
+ Main.client?.logOutput("Starting build...")
 
  val cacheFile = executor.run()
  logger.debug("Build action executed")