Migrate to SAF for file access

Author: syntaxerror247

app/build.gradle

@@ -84,6 +84,7 @@ dependencies {
     implementation libs.androidx.compose.ui.graphics
     implementation libs.androidx.compose.ui.tooling.preview
     implementation libs.androidx.compose.material3
+    implementation libs.androidx.documentfile
     testImplementation libs.junit
     androidTestImplementation libs.androidx.junit
     androidTestImplementation libs.androidx.espresso.core

app/src/main/AndroidManifest.xml

@@ -1,10 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
-    <uses-permission
-        android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
-        tools:ignore="ScopedStorage" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission
         android:name="android.permission.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="29" />

app/src/main/java/org/godotengine/godot_gradle_build_environment/BuildEnvironment.kt

@@ -1,9 +1,13 @@
 package org.godotengine.godot_gradle_build_environment
 
+import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
+import android.net.Uri
 import android.os.Build
-import android.os.Environment
 import android.util.Log
+import androidx.core.content.ContextCompat.checkSelfPermission
+import androidx.core.net.toUri
 import java.io.BufferedReader
 import java.io.File
 import java.io.FileOutputStream
@@ -36,6 +40,9 @@ class BuildEnvironment(
 
     private var currentProcess: Process? = null
 
+    private val accessLock = Object()
+    @Volatile private var grantedTreeUri: Uri? = null
+
     private fun getDefaultEnv(): List<String> {
         return try {
             File(rootfs, "env").readLines()
@@ -153,38 +160,58 @@ class BuildEnvironment(
         return exitCode
     }
 
-    private fun setupProject(projectPath: String, gradleBuildDir: String): File {
-        val fullPath = File(projectPath, gradleBuildDir)
-        val hash = Integer.toHexString(fullPath.absolutePath.hashCode())
-        val workDir = File(projectRoot, hash)
-
-        // Clean up assets from a previous export.
+    private fun setupProject(projectPath: String, gradleBuildDir: String, outputHandler: (Int, String) -> Unit): File {
+        val projectTreeUri: Uri
+        val workDir = Utils.getProjectCacheDir(context, projectPath, gradleBuildDir)
         if (workDir.exists()) {
-            val apkAssetsDir = File(workDir, "src/main/assets")
-            if (apkAssetsDir.exists()) {
-                apkAssetsDir.deleteRecursively()
+            val info = ProjectInfo.readFromDirectory(workDir)
+            if (info != null) {
+                projectTreeUri = info.projectTreeUri.toUri()
+            } else {
+                throw Exception("Could not get projectTreeUri.")
             }
-
-            val aabAssetsDir = File(workDir, "assetPackInstallTime/src/main/assets")
-            if (aabAssetsDir.exists()) {
-                aabAssetsDir.deleteRecursively()
+        } else {
+            if (checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED) {
+                outputHandler(OUTPUT_STDERR, "Project path \"$projectPath\" is not accessible. Click on notification and give GABE app access to this directory.")
+                Utils.showDirectoryAccessNotification(context, projectPath)
+            } else {
+                throw SecurityException("POST_NOTIFICATIONS permission not granted. Please grant POST_NOTIFICATIONS permission for GABE app and retry.")
             }
-        }
 
-        if (!FileUtils.tryCopyDirectory(fullPath, workDir)) {
-            throw IOException("Failed to copy $fullPath to $workDir")
+            // 2 minute wait should be ideal?
+            projectTreeUri = waitForDirectoryAccess(2 * 60 * 1000)
+                ?: throw Exception("Directory access not granted in time. Build canceled.")
+            outputHandler(OUTPUT_STDOUT, "Access granted for $projectPath. Starting Gradle build...")
+            workDir.mkdirs()
+            ProjectInfo.writeToDirectory(context, workDir, projectPath, gradleBuildDir, projectTreeUri)
         }
 
-        ProjectInfo.writeToDirectory(workDir, projectPath, gradleBuildDir)
-
+        outputHandler(OUTPUT_INFO, "> Importing project files...")
+        FileUtils.importAndroidProject(context, projectTreeUri, gradleBuildDir, workDir)
         return workDir
     }
 
-    fun cleanProject(projectPath: String, gradleBuildDir: String) {
-        val fullPath = File(projectPath, gradleBuildDir)
-        val hash = Integer.toHexString(fullPath.absolutePath.hashCode())
-        val workDir = File(projectRoot, hash)
+    private fun fixGradleArgs(projectPath: String, rawGradleArgs: List<String>): List<String> {
+        val normalizedProjectPath = projectPath.trimEnd('/')
+        return rawGradleArgs.map { arg ->
+            when {
+                arg.startsWith("-Pdebug_keystore_file=") -> "-Pdebug_keystore_file=/project/.android/debug.keystore"
+                arg.startsWith("-Prelease_keystore_file=") -> "-Prelease_keystore_file=/project/.android/release.keystore"
+                arg.startsWith("-Paddons_directory=") -> "-Paddons_directory=/project/addons"
+
+                arg.startsWith("-Pplugins_local_binaries=") -> {
+                    val prefix = "-Pplugins_local_binaries="
+                    val value = arg.removePrefix(prefix)
+                    val updated = value.replace("$normalizedProjectPath/addons", "/project/addons")
+                    prefix + updated
+                }
+                else -> arg
+            }
+        }
+    }
 
+    fun cleanProject(projectPath: String, gradleBuildDir: String) {
+        val workDir = Utils.getProjectCacheDir(context, projectPath, gradleBuildDir)
         if (workDir.exists()) {
             workDir.deleteRecursively()
         }
@@ -336,7 +363,7 @@ class BuildEnvironment(
             gradleCmd,
         )
         val binds = listOf(
-            Environment.getExternalStorageDirectory().absolutePath,
+            "/storage/emulated/0:/storage/emulated/0",
             "${workDir.absolutePath}:/project",
             "${gradleCache.absolutePath}:/project/?",
         )
@@ -348,14 +375,14 @@ class BuildEnvironment(
         return AppPaths.getRootfsReadyFile(File(rootfs)).exists()
     }
 
-    fun executeGradle(gradleArgs: List<String>, projectPath: String, gradleBuildDir: String, outputHandler: (Int, String) -> Unit): Int {
+    fun executeGradle(rawGradleArgs: List<String>, projectPath: String, gradleBuildDir: String, outputHandler: (Int, String) -> Unit): Int {
         if (!isRootfsReady()) {
             outputHandler(OUTPUT_STDERR, "Rootfs isn't installed. Install it in the Godot Gradle Build Environment app.")
             return 255
         }
 
         val workDir = try {
-            setupProject(projectPath, gradleBuildDir)
+            setupProject(projectPath, gradleBuildDir, outputHandler)
         } catch (e: Exception) {
             outputHandler(OUTPUT_STDERR, "Unable to setup project: ${e.message}")
             return 255
@@ -371,12 +398,14 @@ class BuildEnvironment(
             outputHandler(type, line)
         }
 
+        val gradleArgs = fixGradleArgs(projectPath, rawGradleArgs)
+
         var result = executeGradleInternal(gradleArgs, workDir, captureOutputHandler)
 
         val stderr = stderrBuilder.toString()
         if (result == 0 && stderr.contains("BUILD FAILED")) {
             // Sometimes Gradle builds fail, but it still gives an exit code of 0.
-            result = 1;
+            result = 1
         }
         stderrBuilder.clear()
 
@@ -399,7 +428,7 @@ class BuildEnvironment(
             result = executeGradleInternal(gradleArgs, workDir, captureOutputHandler)
             val stderr = stderrBuilder.toString()
             if (result == 0 && stderr.contains("BUILD FAILED")) {
-                result = 1;
+                result = 1
             }
         }
 
@@ -417,4 +446,25 @@ class BuildEnvironment(
         }
     }
 
-}
+    fun waitForDirectoryAccess(timeoutMs: Long): Uri? {
+        val endTime = System.currentTimeMillis() + timeoutMs
+
+        synchronized(accessLock) {
+            while (grantedTreeUri == null) {
+                val remaining = endTime - System.currentTimeMillis()
+                if (remaining <= 0) {
+                    return null
+                }
+                accessLock.wait(remaining)
+            }
+            return grantedTreeUri
+        }
+    }
+
+    fun onDirectoryAccessGranted(uri: Uri) {
+        synchronized(accessLock) {
+            grantedTreeUri = uri
+            accessLock.notifyAll()
+        }
+    }
+}

app/src/main/java/org/godotengine/godot_gradle_build_environment/BuildEnvironmentService.kt

@@ -11,6 +11,7 @@ import android.os.Message
 import android.os.Messenger
 import android.os.RemoteException
 import android.util.Log
+import androidx.core.net.toUri
 import java.util.concurrent.LinkedBlockingQueue
 
 class BuildEnvironmentService : Service() {
@@ -26,6 +27,8 @@ class BuildEnvironmentService : Service() {
         const val MSG_CLEAN_GLOBAL_CACHE = 6
         const val MSG_INSTALL_ROOTFS = 7
         const val MSG_DELETE_ROOTFS = 8
+
+        const val MSG_RESUME_PENDING_BUILD = 9
     }
 
     private lateinit var mMessenger: Messenger
@@ -62,6 +65,12 @@ class BuildEnvironmentService : Service() {
                     MSG_CLEAN_GLOBAL_CACHE -> queueWork(WorkItem(copy, msg.arg1))
                     MSG_INSTALL_ROOTFS -> queueWork(WorkItem(copy, msg.arg1))
                     MSG_DELETE_ROOTFS -> queueWork(WorkItem(copy, msg.arg1))
+                    MSG_RESUME_PENDING_BUILD -> {
+                        val uri = msg.data.getString("tree_uri")?.toUri()
+                        if (uri != null) {
+                            mBuildEnvironment.onDirectoryAccessGranted(uri)
+                        }
+                    }
                 }
             }
         }
@@ -88,7 +97,7 @@ class BuildEnvironmentService : Service() {
             return
         }
 
-        Log.i(TAG, "Canceling command: ${id}")
+        Log.i(TAG, "Canceling command: $id")
 
         if (currentItem?.id == id && currentItem?.msg?.what == MSG_EXECUTE_GRADLE) {
             mBuildEnvironment.killCurrentProcess()
@@ -131,7 +140,7 @@ class BuildEnvironmentService : Service() {
         var result = 255
 
         if (args != null && projectPath != null && gradleBuildDir != null) {
-            result = mBuildEnvironment.executeGradle(args, projectPath, gradleBuildDir, { type, line ->
+            result = mBuildEnvironment.executeGradle(args, projectPath, gradleBuildDir) { type, line ->
                 val reply = Message.obtain(null, MSG_COMMAND_OUTPUT, id, type)
                 val replyData = Bundle()
                 replyData.putString("line", line)
@@ -142,7 +151,7 @@ class BuildEnvironmentService : Service() {
                 } catch (e: RemoteException) {
                     Log.e(TAG, "Error send command output to client: ${e.message}")
                 }
-            })
+            }
         }
 
         val reply = Message.obtain(null, MSG_COMMAND_RESULT, id, result)

app/src/main/java/org/godotengine/godot_gradle_build_environment/FileUtils.kt

@@ -1,9 +1,11 @@
 package org.godotengine.godot_gradle_build_environment
 
+import android.content.Context
+import android.net.Uri
 import android.os.Build
 import android.util.Log
+import androidx.documentfile.provider.DocumentFile
 import java.io.File
-import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.io.IOException
 import java.nio.file.Files
@@ -25,21 +27,6 @@ object FileUtils {
         return true
     }
 
-    fun tryCopyDirectory(sourceDir: File, destDir: File): Boolean {
-        if (!sourceDir.isDirectory) {
-            Log.e(TAG, "Source directory ${sourceDir.absolutePath} not found")
-            return false
-        }
-
-        try {
-            sourceDir.copyRecursively(destDir)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to copy ${sourceDir.absolutePath} -> ${destDir.absolutePath}: ${e.message}", e)
-            return false
-        }
-        return true
-    }
-
     /**
      * Recursively calculates the total size of a directory in bytes.
      */
@@ -85,4 +72,69 @@ object FileUtils {
         return String.format("%.1f %s", value, units[unitIndex])
     }
 
+    fun importAndroidProject(context: Context, projectTreeUri: Uri, gradleBuildDir: String, destDir: File) {
+        val root = DocumentFile.fromTreeUri(context, projectTreeUri)
+            ?: throw IOException("Invalid tree uri")
+
+        val androidDir = findDirByPath(root, gradleBuildDir)
+            ?: throw IOException("Gradle build dir not found: $gradleBuildDir")
+
+        val addonsDir = root.listFiles().firstOrNull {
+            it.isDirectory && it.name == "addons"
+        }
+
+        if (destDir.exists()) {
+            val apkAssetsDir = File(destDir, "src/main/assets")
+            if (apkAssetsDir.exists()) apkAssetsDir.deleteRecursively()
+
+            val aabAssetsDir = File(destDir, "assetPackInstallTime/src/main/assets")
+            if (aabAssetsDir.exists()) aabAssetsDir.deleteRecursively()
+        } else {
+            destDir.mkdir()
+        }
+
+        copyDirectoryMerge(context, androidDir, destDir)
+
+        if (addonsDir != null) {
+            val localAddons = File(destDir, "addons")
+            if (localAddons.exists()) {
+                localAddons.deleteRecursively()
+            }
+            localAddons.mkdirs()
+            copyDirectoryMerge(context, addonsDir, localAddons)
+        }
+    }
+
+    private fun findDirByPath(parent: DocumentFile, relativePath: String): DocumentFile? {
+        var current: DocumentFile? = parent
+
+        val parts = relativePath.trim('/').split('/')
+
+        for (part in parts) {
+            current = current?.listFiles()?.firstOrNull {
+                it.isDirectory && it.name == part
+            } ?: return null
+        }
+
+        return current
+    }
+
+    private fun copyDirectoryMerge(context: Context, src: DocumentFile, dest: File) {
+        src.listFiles().forEach { file ->
+            val name = file.name ?: return@forEach
+
+            if (file.isDirectory) {
+                val newDir = File(dest, name)
+                if (!newDir.exists()) newDir.mkdirs()
+                copyDirectoryMerge(context, file, newDir)
+            } else {
+                val outFile = File(dest, name)
+                context.contentResolver.openInputStream(file.uri).use { input ->
+                    FileOutputStream(outFile, false).use { output ->
+                        input?.copyTo(output)
+                    }
+                }
+            }
+        }
+    }
 }