Update

Zenlua · Zenlua · commit 15bbd6020eed · 2026-04-12T01:16:07.000+07:00
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@
 
 - Supports both `root` or `no-root` versions and is only for `arm64-bit`
 
-- 💾 Download: **[Release](https://github.com/Zenlua/Tool-Tree/releases/latest)** or **[Beta](https://github.com/Zenlua/Tool-Tree/releases/tag/beta)**
+- 📲 Download: **[Release](https://github.com/Zenlua/Tool-Tree/releases/latest)** or **[Beta](https://github.com/Zenlua/Tool-Tree/releases/tag/beta)**
 
 ### See details
 
diff --git a/app/src/main/java/com/omarea/krscript/config/PathAnalysis.kt b/app/src/main/java/com/omarea/krscript/config/PathAnalysis.kt
@@ -7,154 +7,133 @@ import com.omarea.common.shell.RootFile
 import com.omarea.krscript.FileOwner
 import java.io.File
 import java.io.InputStream
+import java.net.URI
 
 class PathAnalysis(private var context: Context, private var parentDir: String = "") {
-    private val ASSETS_FILE = "file:///android_asset/"
+    companion object {
+        private const val ASSETS_FILE = "file:///android_asset/"
+    }
 
-    // 解析路径时自动获得
     private var currentAbsPath: String = ""
 
-    fun getCurrentAbsPath(): String {
-        return currentAbsPath
-    }
+    fun getCurrentAbsPath(): String = currentAbsPath
 
     fun parsePath(filePath: String): InputStream? {
-        try {
+        return try {
             if (filePath.startsWith(ASSETS_FILE)) {
                 currentAbsPath = filePath
-                return context.assets.open(filePath.substring(ASSETS_FILE.length))
+                context.assets.open(filePath.substring(ASSETS_FILE.length))
             } else {
-                return getFileByPath(filePath)
+                getFileByPath(filePath)
             }
         } catch (ex: Exception) {
-            return null
+            null
         }
     }
 
-    // TODO:处理 ../ 、 ./
+    /**
+     * Tối ưu hóa việc nối đường dẫn bằng cách sử dụng java.net.URI 
+     * để tự động xử lý các ký hiệu ../ và ./ một cách chuẩn xác.
+     */
     private fun pathConcat(parent: String, target: String): String {
-        val isAssets = parent.startsWith(ASSETS_FILE)
-        val parentDir = if (isAssets) parent.substring(ASSETS_FILE.length) else parent
-        val parentSlices = ArrayList(parentDir.split("/"))
-        if (target.startsWith("../") && parentSlices.isNotEmpty()) {
-            val targetSlices = ArrayList(target.split("/"))
-            while (true) {
-                val step = targetSlices.firstOrNull()
-                if (step != null && step == ".." && parentSlices.isNotEmpty()) {
-                    parentSlices.removeAt(parentSlices.size - 1)
-                    targetSlices.removeAt(0)
-                } else {
-                    break
-                }
-            }
-            return pathConcat((if (isAssets) ASSETS_FILE  else "" )+ parentSlices.joinToString("/"), targetSlices.joinToString("/"))
+        return try {
+            val isAssets = parent.startsWith(ASSETS_FILE)
+            val base = if (isAssets) parent else "file://$parent"
+            
+            // Sử dụng URI để normalize đường dẫn (xử lý ../ và ./)
+            val uri = URI(base).resolve(target).normalize()
+            
+            val result = uri.toString()
+            if (isAssets) result else result.removePrefix("file:")
+        } catch (e: Exception) {
+            // Fallback nếu URI fail
+            if (parent.endsWith("/")) parent + target else "$parent/$target"
         }
-
-        return (if (isAssets) ASSETS_FILE  else "" )+ ( when {
-            !(parentDir.isEmpty() || parentDir.endsWith("/")) -> "$parentDir/"
-            else -> parentDir
-        } + (if (target.startsWith("./")) target.substring(2) else target))
     }
 
+    /**
+     * Cải tiến việc mở file bằng Root: sử dụng tên file động để tránh xung đột (Collision)
+     */
     private fun useRootOpenFile(filePath: String): InputStream? {
         if (RootFile.fileExists(filePath)) {
-            val dir = File(FileWrite.getPrivateFilePath(context, "icons"))
-            if (!dir.exists()) {
-                dir.mkdirs()
-            }
+            val cacheDir = File(FileWrite.getPrivateFilePath(context, "icons"))
+            if (!cacheDir.exists()) cacheDir.mkdirs()
 
-            val cachePath = FileWrite.getPrivateFilePath(context, "icons/outside_file.cache")
+            // Tạo tên file cache dựa trên hash đường dẫn để tránh ghi đè khi mở nhiều file cùng lúc
+            val fileName = "cache_${filePath.hashCode()}"
+            val cachePath = File(cacheDir, fileName).absolutePath
             val fileOwner = FileOwner(context).fileOwner
-            KeepShellPublic.doCmdSync(
-                    "cp -f \"$filePath\" \"$cachePath\"\n" +
-                            "chmod 777 \"$cachePath\"\n" +
-                            "chown $fileOwner:$fileOwner \"$cachePath\"\n")
-            File(cachePath).run {
-                if (exists() && canRead()) {
-                    return inputStream()
+
+            val command = """
+                cp -f "$filePath" "$cachePath"
+                chmod 777 "$cachePath"
+                chown $fileOwner:$fileOwner "$cachePath"
+            """.trimIndent()
+
+            KeepShellPublic.doCmdSync(command)
+            
+            File(cachePath).let {
+                if (it.exists() && it.canRead()) {
+                    return it.inputStream()
                 }
             }
         }
         return null
     }
 
-    // 在assets里查找文件
     private fun findAssetsResource(filePath: String): InputStream? {
-        // 解析成绝对路径
         val relativePath = pathConcat(parentDir, filePath)
-        try {
+        return try {
+            val simplePath = relativePath.substring(ASSETS_FILE.length)
+            context.assets.open(simplePath).also { currentAbsPath = relativePath }
+        } catch (ex: Exception) {
             try {
-                // 首先在assets里查找相对路径
-                val simplePath = relativePath.substring(ASSETS_FILE.length)
-                context.assets.open(simplePath).run {
-                    currentAbsPath = relativePath
-                    return this
-                }
-            } catch (ex: java.lang.Exception) {
-                // 然后再尝试再assets里查找绝对路径
-                context.assets.open(filePath).run {
-                    currentAbsPath = ASSETS_FILE + filePath
-                    return this
-                }
+                context.assets.open(filePath).also { currentAbsPath = ASSETS_FILE + filePath }
+            } catch (e: Exception) {
+                null
             }
-        } catch (ex: java.lang.Exception) {
-            return null
         }
     }
 
-    // 在磁盘上查找文件
     private fun findDiskResource(filePath: String): InputStream? {
+        // 1. Tìm tương đối so với parentDir
         if (parentDir.isNotEmpty()) {
-            // 解析成绝对路径
             val relativePath = pathConcat(parentDir, filePath)
-            // 尝试使用普通权限读取文件
-            File(relativePath).run {
-                if (exists() && canRead()) {
-                    currentAbsPath = absolutePath
-                    return inputStream()
-                }
-            }
-            useRootOpenFile(relativePath)?.run {
-                return this
+            val file = File(relativePath)
+            if (file.exists() && file.canRead()) {
+                currentAbsPath = file.absolutePath
+                return file.inputStream()
             }
+            useRootOpenFile(relativePath)?.let { return it }
         }
 
-        // 路径相对于当前配置文件没找到文件的话，继续查找相对于数据文件根目录的文件
-        val privatePath = File( pathConcat(FileWrite.getPrivateFileDir(context), filePath)).absolutePath
-        File(privatePath).run {
-            if (exists() && canRead()) {
-                currentAbsPath = absolutePath
-                return inputStream()
-            }
-        }
-        useRootOpenFile(privatePath)?.run {
-            return this
+        // 2. Tìm trong thư mục riêng của ứng dụng (Private Data)
+        val privateDir = FileWrite.getPrivateFileDir(context)
+        val privatePath = pathConcat(privateDir, filePath)
+        val pFile = File(privatePath)
+        if (pFile.exists() && pFile.canRead()) {
+            currentAbsPath = pFile.absolutePath
+            return pFile.inputStream()
         }
-
-        return null
+        
+        return useRootOpenFile(privatePath)
     }
 
     private fun getFileByPath(filePath: String): InputStream? {
-        try {
+        return try {
             if (filePath.startsWith("/")) {
                 currentAbsPath = filePath
-                val javaFileInfo = File(filePath)
-                return if (javaFileInfo.exists() && javaFileInfo.canRead()) {
-                    javaFileInfo.inputStream()
-                } else {
-                    useRootOpenFile(filePath)
-                }
+                val file = File(filePath)
+                if (file.exists() && file.canRead()) file.inputStream() else useRootOpenFile(filePath)
             } else {
-                // 如果当前配置文件来源于 assets，则查找依赖资源时也只去assets查找
-                return if (parentDir.isNotEmpty() && parentDir.startsWith(ASSETS_FILE)) {
+                if (parentDir.startsWith(ASSETS_FILE)) {
                     findAssetsResource(filePath)
                 } else {
                     findDiskResource(filePath)
                 }
             }
-        } catch (ex: java.lang.Exception) {
-            ex.printStackTrace()
+        } catch (ex: Exception) {
+            null
         }
-        return null
     }
 }
diff --git a/app/src/main/java/com/omarea/krscript/shortcut/ActionShortcutManager.kt b/app/src/main/java/com/omarea/krscript/shortcut/ActionShortcutManager.kt
