ADFA-4930: relocate Gradle build output by default

ARCHITECTURE.md

@@ -63,6 +63,13 @@ The optional file path is attacker-controllable (a URL segment), so it's resolve
 
 Whether the open project *can* be named at all is `isDeepLinkTargetOfOpenProject` (`ProjectValidations.kt`): a link can only ever resolve to `<projectsRoot>/<name>`, but a project can be opened from anywhere. Its `deepLinkTargetOfOpenProjectWithoutIo` half exists so a caller on the main thread can settle the common case — equal path strings name the same directory — without the `canonicalPath` calls the full rule needs. `CreateLinkAction` sends its residue to `Dispatchers.IO` rather than to the StrictMode whitelist (ADR 0007); the two older callers (`EditorHandlerActivity.onNewIntent`, `BaseEditorActivity.onCreate`) still fall through to `canonicalPath` on the main thread and have not been migrated, so the shortcut narrows that exposure rather than removing it.
 
+**Gradle build output lives in app storage, not the project folder (ADFA-4930).** Projects sit on shared storage (`/sdcard`), which Android serves through FUSE, so every file a build writes pays a user-space round trip. Each project's build output goes to `noBackupFilesDir/gradle-build/<projectKey>/` (`services/builder/BuildOutputLocation`), keyed like Quick Build's scratch (`ProjectStorageKey` in `:shared`):
+- `main/<name>-<hash>/` per Gradle project (`<hash>` of its full path, so `:core:ui` is not inside `:core`'s output); nested builds get their own key. The init script plugin sets `layout.buildDirectory` from `-Pcotg.build.outputDir` (`gradle-plugin/.../BuildOutputRedirect`).
+- `project-cache/` (`--project-cache-dir`, Gradle's `.gradle/`) and `kotlin/` (`kotlin.project.persistent.dir`), for the main build; an included build keeps its own, as Gradle passes neither setting to it.
+- `project-path`, a marker naming the project, used to delete a project's output with it and to sweep orphans at startup.
+
+**The synced model is the record of where output goes.** Every sync relocates, and opening a project does not sync, so an existing project's cached model keeps building into the project folder until its next sync; a build relocates exactly when any project's build directory in the model is in the tree (a build script that sets its own overrides the relocation for that project alone), so its output is always where the model (APK listing file, classpath, Quick Build's `setup.json`, a plugin's `.cgp`) looks, and a sync that fails changes neither. Code that needs build output reads it from the model's build directories, never from `<project>/build`. Builds started outside the IDE (`./gradlew` in the terminal) don't get the redirect and still write to the project folder. After a project's first relocated initialization, the stale output its folder still held is removed once (`services/builder/OldBuildOutput`), without following symlinks.
+
 ## Module Structure
 
 Strategy: **layer-and-subsystem based**, not feature-by-feature. The Gradle build has ~80 modules (`settings.gradle.kts`) plus three included composite builds. `app` is the integration point; the rest are libraries it composes.

app/src/main/java/com/itsaky/androidide/actions/etc/ExportApkAction.kt → app/src/main/java/com/itsaky/androidide/actions/etc/ExportBuildAction.kt

@@ -14,14 +14,16 @@ import com.itsaky.androidide.idetooltips.TooltipTag.EDITOR_TOOLBAR_EXPORT_APK
 import com.itsaky.androidide.lookup.Lookup
 import com.itsaky.androidide.projects.IProjectManager
 import com.itsaky.androidide.projects.builder.BuildService
+import com.itsaky.androidide.projects.isPluginProject
 import com.itsaky.androidide.projects.models.assembleTaskOutputListingFile
 import com.itsaky.androidide.projects.models.buildDir
 import com.itsaky.androidide.quickbuild.QuickBuildTaskPaths
-import com.itsaky.androidide.utils.ApkExport
+import com.itsaky.androidide.utils.BuildExport
 import com.itsaky.androidide.utils.DialogUtils
 import com.itsaky.androidide.utils.IntentUtils
 import com.itsaky.androidide.utils.flashError
 import com.itsaky.androidide.utils.flashSuccess
+import com.itsaky.androidide.viewmodel.findPluginCgpFile
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -30,21 +32,22 @@ import java.io.File
 import java.io.IOException
 
 /**
- * Hands over the selected variant's built APK (ADFA-4930): with relocated build output it is in
- * app-private storage, where a file manager cannot reach it. Offers the share sheet, or a copy in
- * the Download folder.
+ * Hands over what the selected variant built (ADFA-4930): its APK, its App Bundle, or a plugin
+ * project's `.cgp`. With relocated build output they are in app-private storage, where a file
+ * manager cannot reach them. Offers the share sheet, or a copy in the Download folder.
  */
-class ExportApkAction(
+class ExportBuildAction(
 	context: Context,
 	override val order: Int,
 ) : EditorActivityAction() {
+	// Named when only the APK was exported; documentation.db keys the tooltip on the tag.
 	override val id: String = "ide.editor.exportApk"
 	override var requiresUIThread: Boolean = true
 
 	override fun retrieveTooltipTag(isReadOnlyContext: Boolean) = EDITOR_TOOLBAR_EXPORT_APK
 
 	init {
-		label = context.getString(R.string.title_export_apk)
+		label = context.getString(R.string.title_export_build)
 		icon = ContextCompat.getDrawable(context, R.drawable.ic_share)
 	}
 
@@ -75,78 +78,116 @@ class ExportApkAction(
 			val activity = data.requireActivity()
 			val projectManager = IProjectManager.getInstance()
 			val projectDir = File(projectManager.projectDirPath)
+			val isPlugin = projectManager.isPluginProject()
 			// The module only when it tells two app modules' exports apart.
 			val module = app.name.takeIf { projectManager.getAndroidAppModules().size > 1 }
 			val name = listOfNotNull(projectDir.name, module, variant.name).joinToString("-")
 			activity.activityScope.launch {
-				val found =
+				val (apk, outputs) =
 					withContext(Dispatchers.IO) {
-						ApkExport.resolve(
-							listingFile = variant.mainArtifact.assembleTaskOutputListingFile,
-							quickBuildReport = QuickBuildTaskPaths.setupJson(app.buildDir, variant.name),
-							projectDir = projectDir,
-						)
+						val apk =
+							BuildExport.resolve(
+								listingFile = variant.mainArtifact.assembleTaskOutputListingFile,
+								quickBuildReport = QuickBuildTaskPaths.setupJson(app.buildDir, variant.name),
+								projectDir = projectDir,
+							)
+						apk to
+							BuildExport.outputs(
+								apk = apk,
+								bundle = BuildExport.findBundle(app.buildDir, variant.name),
+								plugin = if (isPlugin) findPluginCgpFile(projectManager.workspace, variant.name) else null,
+							)
+					}
+				withContext(Dispatchers.Main) {
+					when {
+						outputs.size == 1 -> offerExport(activity, outputs.single(), name)
+						outputs.isNotEmpty() -> chooseOutput(activity, outputs, name)
+						isPlugin -> flashError(R.string.msg_export_plugin_not_built)
+						apk == BuildExport.Exportable.QuickBuildProxy -> flashError(R.string.msg_export_apk_quick_build)
+						else -> flashError(R.string.msg_export_not_built)
 					}
-				when (found) {
-					ApkExport.Exportable.NotBuilt -> flashError(R.string.msg_export_apk_not_built)
-					ApkExport.Exportable.QuickBuildProxy -> flashError(R.string.msg_export_apk_quick_build)
-					is ApkExport.Exportable.Apk -> withContext(Dispatchers.Main) { offerExport(activity, found.file, name) }
 				}
 			}
 		}
 	}
 
 	private fun buildService(): BuildService? = Lookup.getDefault().lookup(BuildService.KEY_BUILD_SERVICE)
 
-	/** A build, Quick Build's prebuild included, may be rewriting the APK; refuse with a reason. */
+	/** A build, Quick Build's prebuild included, may be rewriting the output; refuse with a reason. */
 	private fun isBuilding(): Boolean {
 		if (buildService()?.isBuildInProgress != true) return false
-		flashError(R.string.msg_export_apk_build_running)
+		flashError(R.string.msg_export_build_running)
 		return true
 	}
 
+	private fun labelOf(
+		context: Context,
+		kind: BuildExport.Kind,
+	): String =
+		context.getString(
+			when (kind) {
+				BuildExport.Kind.APK -> R.string.export_kind_apk
+				BuildExport.Kind.BUNDLE -> R.string.export_kind_bundle
+				BuildExport.Kind.PLUGIN -> R.string.export_kind_plugin
+			},
+		)
+
+	private fun chooseOutput(
+		activity: EditorHandlerActivity,
+		outputs: List<BuildExport.Output>,
+		name: String,
+	) {
+		DialogUtils
+			.newMaterialDialogBuilder(activity)
+			.setTitle(R.string.title_export_build)
+			.setItems(outputs.map { labelOf(activity, it.kind) }.toTypedArray()) { _, which ->
+				offerExport(activity, outputs[which], name)
+			}.setNegativeButton(android.R.string.cancel, null)
+			.show()
+	}
+
 	private fun offerExport(
 		activity: EditorHandlerActivity,
-		apk: File,
+		output: BuildExport.Output,
 		name: String,
 	) {
 		DialogUtils
 			.newMaterialDialogBuilder(activity)
-			.setTitle(R.string.title_export_apk)
+			.setTitle(activity.getString(R.string.title_export_kind, labelOf(activity, output.kind)))
 			.setItems(
 				arrayOf(
-					activity.getString(R.string.export_apk_share),
-					activity.getString(R.string.export_apk_copy_to_download),
+					activity.getString(R.string.export_share),
+					activity.getString(R.string.export_copy_to_download),
 				),
 			) { _, which ->
 				if (which == 0) {
-					IntentUtils.shareFile(activity, apk, ApkExport.MIME_TYPE)
+					IntentUtils.shareFile(activity, output.file, output.kind.mimeType)
 				} else if (!isBuilding()) {
-					activity.activityScope.launch(Dispatchers.IO) { copyToDownload(activity, apk, name) }
+					activity.activityScope.launch(Dispatchers.IO) { copyToDownload(activity, output, name) }
 				}
 			}.setNegativeButton(android.R.string.cancel, null)
 			.show()
 	}
 
 	private fun copyToDownload(
 		activity: EditorHandlerActivity,
-		apk: File,
+		output: BuildExport.Output,
 		name: String,
 	) {
 		@Suppress("DEPRECATION")
 		val download = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
 		try {
-			val copy = ApkExport.copyTo(apk, download, name)
-			flashSuccess(activity.getString(R.string.msg_export_apk_saved, copy.name))
+			val copy = BuildExport.copyTo(output.file, download, name, output.kind.extension)
+			flashSuccess(activity.getString(R.string.msg_export_saved, copy.name))
 		} catch (e: IOException) {
-			log.error("Cannot copy {} to {}", apk, download, e)
-			flashError(R.string.msg_export_apk_failed)
+			log.error("Cannot copy {} to {}", output.file, download, e)
+			flashError(R.string.msg_export_failed)
 		}
 	}
 
 	override fun getShowAsActionFlags(data: ActionData): Int = MenuItem.SHOW_AS_ACTION_IF_ROOM
 
 	companion object {
-		private val log = LoggerFactory.getLogger(ExportApkAction::class.java)
+		private val log = LoggerFactory.getLogger(ExportBuildAction::class.java)
 	}
 }