feat: Store merged APK from split archives as original for repatching (#438)

MarcaDian · web-flow · commit be0b86866f5e · 2026-04-17T09:49:28.000+03:00
diff --git a/app/src/main/java/app/morphe/manager/ManagerApplication.kt b/app/src/main/java/app/morphe/manager/ManagerApplication.kt
@@ -170,5 +170,9 @@ class ManagerApplication : Application() {
             deleteRecursively()
             mkdirs()
         }
+        // Logs all app-private directories and their contents with file sizes on fresh start
+        scope.launch(Dispatchers.IO) {
+            fs.logStorageContents()
+        }
     }
 }
diff --git a/app/src/main/java/app/morphe/manager/data/platform/Filesystem.kt b/app/src/main/java/app/morphe/manager/data/platform/Filesystem.kt
@@ -6,12 +6,16 @@ import android.content.Context
 import android.content.pm.PackageManager
 import android.os.Build
 import android.os.Environment
+import android.util.Log
 import androidx.activity.result.contract.ActivityResultContract
 import androidx.activity.result.contract.ActivityResultContracts
 import app.morphe.manager.util.FilenameUtils
 import app.morphe.manager.util.RequestManageStorageContract
+import app.morphe.manager.util.formatBytes
 import java.io.File
 
+private const val TAG = "Filesystem"
+
 class Filesystem(private val app: Application) {
     /**
      * A directory that gets cleared when the app restarts.
@@ -57,4 +61,31 @@ class Filesystem(private val app: Application) {
         val safeVersion = FilenameUtils.sanitize(version.ifBlank { "unspecified" })
         return patchedAppsDir.resolve("${safePackage}_${safeVersion}.apk")
     }
+
+    /**
+     * Logs all app-private directories and their contents with file sizes.
+     * Useful for diagnosing storage issues on startup.
+     */
+    fun logStorageContents() {
+        Log.i(TAG, "=== Storage contents ===")
+        for (dir in listOf(tempDir, uiTempDir, patchedAppsDir, originalApksDir)) {
+            logDir(dir.name, dir)
+        }
+        Log.i(TAG, "=== End of storage contents ===")
+    }
+
+    private fun logDir(label: String, dir: File, indent: String = "") {
+        val totalSize = dir.walkBottomUp().filter { it.isFile }.sumOf { it.length() }
+        Log.i(TAG, "$indent[$label] ${dir.absolutePath} (total: ${formatBytes(totalSize)})")
+        dir.listFiles()
+            ?.sortedWith(compareBy({ it.isFile }, { it.name }))
+            ?.forEach { entry ->
+                if (entry.isDirectory) {
+                    logDir(entry.name, entry, "$indent  ")
+                } else {
+                    Log.i(TAG, "$indent  ${entry.name} (${formatBytes(entry.length())})")
+                }
+            }
+            ?: Log.i(TAG, "$indent  (empty or unreadable)")
+    }
 }
diff --git a/app/src/main/java/app/morphe/manager/patcher/runtime/CoroutineRuntime.kt b/app/src/main/java/app/morphe/manager/patcher/runtime/CoroutineRuntime.kt
@@ -25,6 +25,7 @@ class CoroutineRuntime(private val context: Context) : Runtime(context) {
         onPatchCompleted: suspend () -> Unit,
         onProgress: ProgressEventHandler,
         stripNativeLibs: Boolean,
+        onMergedApkReady: (suspend (File) -> Unit)?,
     ) {
         MemoryMonitor.startMemoryPolling(logger)
 
@@ -68,6 +69,7 @@ class CoroutineRuntime(private val context: Context) : Runtime(context) {
         try {
             if (preparation.merged) {
                 onProgress(null, State.COMPLETED, null)
+                onMergedApkReady?.invoke(preparation.file)
             }
 
             Session(
diff --git a/app/src/main/java/app/morphe/manager/patcher/runtime/ProcessRuntime.kt b/app/src/main/java/app/morphe/manager/patcher/runtime/ProcessRuntime.kt
@@ -15,6 +15,7 @@ import app.morphe.manager.patcher.runtime.process.IPatcherProcess
 import app.morphe.manager.patcher.runtime.process.Parameters
 import app.morphe.manager.patcher.runtime.process.PatchConfiguration
 import app.morphe.manager.patcher.runtime.process.PatcherProcess
+import app.morphe.manager.patcher.split.SplitApkPreparer
 import app.morphe.manager.patcher.worker.ProgressEventHandler
 import app.morphe.manager.ui.model.State
 import app.morphe.manager.util.Options
@@ -114,6 +115,7 @@ class ProcessRuntime(
         onPatchCompleted: suspend () -> Unit,
         onProgress: ProgressEventHandler,
         stripNativeLibs: Boolean,
+        onMergedApkReady: (suspend (File) -> Unit)?,
     ) = coroutineScope {
         val minMemoryLimit = 200
         var memoryMB = max(minMemoryLimit, prefs.patcherProcessMemoryLimit.get())
@@ -131,7 +133,8 @@ class ProcessRuntime(
                     stripNativeLibs,
                     logger,
                     onPatchCompleted,
-                    onProgress
+                    onProgress,
+                    onMergedApkReady
                 )
                 // Success - update preference and return.
                 if (retried && prefs.patcherProcessMemoryLimit.get() != memoryMB) {
@@ -174,6 +177,7 @@ class ProcessRuntime(
         logger: Logger,
         onPatchCompleted: suspend () -> Unit,
         onProgress: ProgressEventHandler,
+        onMergedApkReady: (suspend (File) -> Unit)?,
     ) = coroutineScope {
         // Get the location of our own Apk.
         val managerBaseApk = pm.getPackageInfo(context.packageName)!!.applicationInfo!!.sourceDir
@@ -195,6 +199,14 @@ class ProcessRuntime(
 
         val appProcessBin = resolveAppProcessBin(context)
 
+        // Determine merged APK path before launching the process so it is accessible
+        // after patching.await() to invoke onMergedApkReady in the coroutineScope.
+        val mergedInputPath = if (SplitApkPreparer.isSplitArchive(File(inputFile))) {
+            File(cacheDir).resolve("merged-process-input-${System.currentTimeMillis()}.apk").absolutePath
+        } else {
+            null
+        }
+
         launch(Dispatchers.IO) {
             val result = process(
                 appProcessBin,
@@ -263,14 +275,26 @@ class ProcessRuntime(
                         options[uid].orEmpty()
                     )
                 },
-                stripNativeLibs = stripNativeLibs
+                stripNativeLibs = stripNativeLibs,
+                mergedInputFile = mergedInputPath
             )
 
             binder.start(parameters, eventHandler)
         }
 
-        // Wait until patching finishes.
-        patching.await()
+        // Wait until patching finishes
+        val mergedFile = mergedInputPath?.let { File(it) }
+        try {
+            patching.await()
+            // If PatcherProcess merged a split archive, notify the caller so the merged APK
+            // can be saved to originalApksDir for future repatching
+            if (mergedFile?.exists() == true) {
+                onMergedApkReady?.invoke(mergedFile)
+            }
+        } finally {
+            // Always clean up the temporary merged file regardless of success or failure
+            mergedFile?.takeIf { it.exists() }?.delete()
+        }
     }
 
     companion object : LibraryResolver() {
diff --git a/app/src/main/java/app/morphe/manager/patcher/runtime/Runtime.kt b/app/src/main/java/app/morphe/manager/patcher/runtime/Runtime.kt
@@ -12,6 +12,7 @@ import app.morphe.manager.util.PatchSelection
 import kotlinx.coroutines.flow.first
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
+import java.io.File
 import java.io.FileNotFoundException
 
 sealed class Runtime(context: Context) : KoinComponent {
@@ -37,5 +38,6 @@ sealed class Runtime(context: Context) : KoinComponent {
         onPatchCompleted: suspend () -> Unit,
         onProgress: ProgressEventHandler,
         stripNativeLibs: Boolean,
+        onMergedApkReady: (suspend (File) -> Unit)? = null,
     )
 }
diff --git a/app/src/main/java/app/morphe/manager/patcher/runtime/process/Parameters.kt b/app/src/main/java/app/morphe/manager/patcher/runtime/process/Parameters.kt
@@ -15,6 +15,9 @@ data class Parameters(
     val outputFile: String,
     val configurations: List<PatchConfiguration>,
     val stripNativeLibs: Boolean,
+    // If non-null, PatcherProcess writes the merged mono-APK to this path after prepareIfNeeded.
+    // ProcessRuntime reads it back so the main process knows the merged file location.
+    val mergedInputFile: String? = null,
 ) : Parcelable
 
 @Parcelize
diff --git a/app/src/main/java/app/morphe/manager/patcher/runtime/process/PatcherProcess.kt b/app/src/main/java/app/morphe/manager/patcher/runtime/process/PatcherProcess.kt
@@ -91,6 +91,12 @@ class PatcherProcess(private val context: Context) : IPatcherProcess.Stub() {
             try {
                 if (preparation.merged) {
                     events.progress(null, State.COMPLETED.name, null)
+
+                    // Copy merged APK to the agreed path so ProcessRuntime can read it back
+                    // in the main process after this process finishes
+                    parameters.mergedInputFile?.let { dest ->
+                        preparation.file.copyTo(File(dest), overwrite = true)
+                    }
                 }
 
                 Session(
diff --git a/app/src/main/java/app/morphe/manager/patcher/worker/PatcherWorker.kt b/app/src/main/java/app/morphe/manager/patcher/worker/PatcherWorker.kt
@@ -20,6 +20,7 @@ import app.morphe.manager.domain.installer.RootInstaller
 import app.morphe.manager.domain.manager.KeystoreManager
 import app.morphe.manager.domain.manager.PreferencesManager
 import app.morphe.manager.domain.repository.InstalledAppRepository
+import app.morphe.manager.domain.repository.OriginalApkRepository
 import app.morphe.manager.domain.worker.Worker
 import app.morphe.manager.domain.worker.WorkerRepository
 import app.morphe.manager.patcher.logger.Logger
@@ -47,6 +48,7 @@ class PatcherWorker(
     private val pm: PM by inject()
     private val fs: Filesystem by inject()
     private val installedAppRepository: InstalledAppRepository by inject()
+    private val originalApkRepository: OriginalApkRepository by inject()
     private val rootInstaller: RootInstaller by inject()
 
     class Args(
@@ -215,6 +217,21 @@ class PatcherWorker(
                 CoroutineRuntime(applicationContext)
             }
 
+            // After merging a split archive (in either runtime), save the resulting mono-APK
+            // directly to originalApksDir so it is used for repatching instead of the archive
+            val onMergedApkReady: suspend (File) -> Unit = { mergedFile ->
+                val version = pm.getPackageInfo(mergedFile)?.versionName
+                    ?.takeUnless { it.isBlank() }
+                    ?: args.input.version
+                    ?: "unknown"
+                val savedFile = originalApkRepository.saveOriginalApk(
+                    packageName = args.packageName,
+                    version = version,
+                    sourceFile = mergedFile
+                )
+                args.setInputFile(savedFile ?: mergedFile, true, true)
+            }
+
             try {
                 runtime.execute(
                     inputFile.absolutePath,
@@ -225,7 +242,8 @@ class PatcherWorker(
                     args.logger,
                     args.onPatchCompleted,
                     args.onProgress,
-                    stripNativeLibs
+                    stripNativeLibs,
+                    onMergedApkReady
                 )
             } catch (e: Exception) {
                 if (!useProcessRuntime || Build.VERSION.SDK_INT > Build.VERSION_CODES.Q || !isOomRelated(e)) {
@@ -243,7 +261,8 @@ class PatcherWorker(
                     args.logger,
                     args.onPatchCompleted,
                     args.onProgress,
-                    stripNativeLibs
+                    stripNativeLibs,
+                    onMergedApkReady
                 )
             }
 
diff --git a/app/src/main/java/app/morphe/manager/ui/viewmodel/HomeViewModel.kt b/app/src/main/java/app/morphe/manager/ui/viewmodel/HomeViewModel.kt
@@ -1334,7 +1334,9 @@ class HomeViewModel(
             }
 
             if (selectedApp != null) {
-                processSelectedApp(selectedApp)
+                // The saved file is a merged mono-APK signed with our keystore.
+                // Skip signature verification to avoid a false "invalid signature" dialog
+                processSelectedAppIgnoringSignature(selectedApp)
             } else {
                 cleanupPendingData()
             }
diff --git a/app/src/main/java/app/morphe/manager/ui/viewmodel/InstalledAppInfoViewModel.kt b/app/src/main/java/app/morphe/manager/ui/viewmodel/InstalledAppInfoViewModel.kt
@@ -73,7 +73,7 @@ class InstalledAppInfoViewModel(
 
                 if (app != null) {
                     // Run all checks in parallel
-                    val deferredMounted = async { rootInstaller.isAppMounted(app.currentPackageName) }
+                    val deferredMounted = async { rootInstaller.isDeviceRooted() && rootInstaller.isAppMounted(app.currentPackageName) }
                     val deferredOriginalApk = async { originalApkRepository.get(app.originalPackageName) != null }
                     val deferredAppState = async { refreshAppState(app) }
                     val deferredPatches = async { resolveAppliedSelection(app) }
@@ -231,7 +231,7 @@ class InstalledAppInfoViewModel(
         }
 
         // Update mounted state
-        isMounted = rootInstaller.isAppMounted(app.currentPackageName)
+        isMounted = rootInstaller.isDeviceRooted() && rootInstaller.isAppMounted(app.currentPackageName)
     }
 
     /** Manually refresh app state (e.g., after app installation/uninstallation) */
diff --git a/app/src/main/java/app/morphe/manager/ui/viewmodel/PatcherViewModel.kt b/app/src/main/java/app/morphe/manager/ui/viewmodel/PatcherViewModel.kt
@@ -425,31 +425,22 @@ class PatcherViewModel(
     /**
      * Save original APK file for future repatching.
      * Called after successful patching, independent of installation method.
-     * For split APK archives (apkm, apks, xapk), saves the original archive.
+     * For split APK archives: inputFile points to the merged mono-APK already saved to
+     * originalApksDir by the worker via onMergedApkReady - this call will detect the
+     * existing record and skip re-saving.
      * For regular APK files, saves the APK itself.
      *
      * Thread-safe: uses mutex to prevent concurrent saves from observeWorker and persistPatchedApp.
      */
     private suspend fun saveOriginalApkIfNeeded() = saveOriginalApkMutex.withLock {
         try {
-            // Determine which file to save:
-            // - For SelectedApp.Local with split archives: save the original user file
-            // - For other cases: save the inputFile (which might be a downloaded/extracted APK)
+            // Determine which file to save.
+            // For SelectedApp.Local with a split archive: inputFile is updated to the merged
+            // mono-APK via setInputFile(merged=true) after prepareIfNeeded() completes, so
+            // we always use inputFile here - it already points to the correct file.
             val fileToSave = when (val selected = input.selectedApp) {
-                is SelectedApp.Local -> {
-                    // Check if original file is a split archive
-                    if (SplitApkPreparer.isSplitArchive(selected.file)) {
-                        // Save the original split archive, not the merged APK
-                        selected.file
-                    } else {
-                        // For regular APK, use inputFile (might be same as selected.file)
-                        inputFile ?: selected.file
-                    }
-                }
-                else -> {
-                    // For non-local apps (Download, Search, Installed), use inputFile
-                    inputFile
-                }
+                is SelectedApp.Local -> inputFile ?: selected.file
+                else -> inputFile
             }
 
             if (fileToSave == null || !fileToSave.exists()) {
@@ -806,7 +797,7 @@ class PatcherViewModel(
                             saveOriginalApkIfNeeded()
                         } finally {
                             withContext(Dispatchers.Main) {
-                                // Delete temporary file after saving
+                                // Delete temporary input file after saving
                                 if (input.selectedApp is SelectedApp.Local && input.selectedApp.temporary) {
                                     inputFile?.takeIf { it.exists() }?.delete()
                                     inputFile = null

Original file line number	Diff line number	Diff line change
`@@ -170,5 +170,9 @@ class ManagerApplication : Application() {`
`170`	`170`	`deleteRecursively()`
`171`	`171`	`mkdirs()`
`172`	`172`	`}`
	`173`	`+ // Logs all app-private directories and their contents with file sizes on fresh start`
	`174`	`+ scope.launch(Dispatchers.IO) {`
	`175`	`+ fs.logStorageContents()`
	`176`	`+ }`
`173`	`177`	`}`
`174`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ import app.morphe.manager.util.PatchSelection`
`12`	`12`	`import kotlinx.coroutines.flow.first`
`13`	`13`	`import org.koin.core.component.KoinComponent`
`14`	`14`	`import org.koin.core.component.inject`
	`15`	`+import java.io.File`
`15`	`16`	`import java.io.FileNotFoundException`
`16`	`17`
`17`	`18`	`sealed class Runtime(context: Context) : KoinComponent {`
`@@ -37,5 +38,6 @@ sealed class Runtime(context: Context) : KoinComponent {`
`37`	`38`	`onPatchCompleted: suspend () -> Unit,`
`38`	`39`	`onProgress: ProgressEventHandler,`
`39`	`40`	`stripNativeLibs: Boolean,`
	`41`	`+ onMergedApkReady: (suspend (File) -> Unit)? = null,`
`40`	`42`	`)`
`41`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1334,7 +1334,9 @@ class HomeViewModel(`
`1334`	`1334`	`}`
`1335`	`1335`
`1336`	`1336`	`if (selectedApp != null) {`
`1337`		`- processSelectedApp(selectedApp)`
	`1337`	`+ // The saved file is a merged mono-APK signed with our keystore.`
	`1338`	`+ // Skip signature verification to avoid a false "invalid signature" dialog`
	`1339`	`+ processSelectedAppIgnoringSignature(selectedApp)`
`1338`	`1340`	`} else {`
`1339`	`1341`	`cleanupPendingData()`
`1340`	`1342`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ class InstalledAppInfoViewModel(`
`73`	`73`
`74`	`74`	`if (app != null) {`
`75`	`75`	`// Run all checks in parallel`
`76`		`- val deferredMounted = async { rootInstaller.isAppMounted(app.currentPackageName) }`
	`76`	`+ val deferredMounted = async { rootInstaller.isDeviceRooted() && rootInstaller.isAppMounted(app.currentPackageName) }`
`77`	`77`	`val deferredOriginalApk = async { originalApkRepository.get(app.originalPackageName) != null }`
`78`	`78`	`val deferredAppState = async { refreshAppState(app) }`
`79`	`79`	`val deferredPatches = async { resolveAppliedSelection(app) }`
`@@ -231,7 +231,7 @@ class InstalledAppInfoViewModel(`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`// Update mounted state`
`234`		`- isMounted = rootInstaller.isAppMounted(app.currentPackageName)`
	`234`	`+ isMounted = rootInstaller.isDeviceRooted() && rootInstaller.isAppMounted(app.currentPackageName)`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`/** Manually refresh app state (e.g., after app installation/uninstallation) */`