Feature/quality selector

app/proguard-rules.pro

@@ -5,4 +5,12 @@
 -keep class com.chaquo.python.runtime.** { *; }
 
 # Shizuku
--keep class com.example.bd2modmanager.service.ShizukuFileService { *; }
+-keep class com.example.bd2modmanager.service.ShizukuFileService { *; }
+
+# Gson: preserve generic signatures for TypeToken
+-keepattributes Signature
+-keep class com.google.gson.reflect.TypeToken { *; }
+-keep class * extends com.google.gson.reflect.TypeToken
+
+# Keep data model classes used with Gson serialization
+-keep class com.example.bd2modmanager.data.model.** { *; }

app/src/main/aidl/com/example/bd2modmanager/IFileService.aidl

@@ -3,5 +3,6 @@ package com.example.bd2modmanager;
 interface IFileService {
     boolean copyFile(String sourcePath, String destPath);
     boolean copyDirectory(String sourceDirPath, String destDirPath);
+    String listBundleDirectory(String sharedDirPath);
     void destroy();
 }

app/src/main/java/com/example/bd2modmanager/MainActivity.kt

@@ -132,6 +132,20 @@ class MainActivity : ComponentActivity() {
                         onDismiss = { viewModel.resetMergeState() }
                     )
                 }
+
+                val showVersionMismatch by viewModel.showVersionMismatchWarning.collectAsState()
+                if (showVersionMismatch) {
+                    VersionMismatchWarningDialog(
+                        onDismiss = { viewModel.dismissVersionMismatchWarning() }
+                    )
+                }
+
+                val bundleScanState by viewModel.bundleScanState.collectAsState()
+                BundleScanDialog(
+                    state = bundleScanState,
+                    onConfirm = { viewModel.confirmBundleScan() },
+                    onDismiss = { viewModel.dismissBundleScan() }
+                )
             }
         }
     }

app/src/main/java/com/example/bd2modmanager/data/model/ModModels.kt

@@ -13,6 +13,7 @@ enum class MatchStrategy {
     EXACT,
     NORMALIZED,
     EXTENSION_MAPPING,
+    LOCAL_SCAN,
     FALLBACK,
     NONE
 }
@@ -123,3 +124,27 @@ sealed class MergeState {
     data class Finished(val message: String) : MergeState()
     data class Failed(val error: String) : MergeState()
 }
+
+sealed class BundleScanState {
+    object Idle : BundleScanState()
+    data class Confirmation(val bundleCount: Int) : BundleScanState()
+    data class Scanning(
+        val currentIndex: Int,
+        val totalCount: Int,
+        val currentBundle: String,
+        val progressMessage: String = ""
+    ) : BundleScanState()
+    data class Finished(
+        val scannedCount: Int,
+        val failedCount: Int,
+        val message: String
+    ) : BundleScanState()
+    data class Failed(val error: String) : BundleScanState()
+}
+
+data class BundleCheckResult(
+    val bundleListJson: String,
+    val needsScanJson: String,
+    val hashMap: Map<String, String>,
+    val needsScanCount: Int
+)

app/src/main/java/com/example/bd2modmanager/data/repository/CharacterRepository.kt

@@ -17,20 +17,26 @@ class CharacterRepository(private val context: Context) {
 
     private var characterLut: Map<String, List<CharacterInfo>> = emptyMap()
 
-    suspend fun updateCharacterData(): Boolean {
+    /**
+     * Returns the update status: "SUCCESS", "SKIPPED", or "FAILED".
+     * - "SUCCESS" means characters.json was regenerated with a new version.
+     * - "SKIPPED" means the local version was already up to date.
+     * - "FAILED" means the update attempt failed.
+     */
+    suspend fun updateCharacterData(quality: String): String {
         return withContext(Dispatchers.IO) {
-            var success = false
+            var status = "FAILED"
             try {
                 if (!Python.isStarted()) {
                     Python.start(com.chaquo.python.android.AndroidPlatform(context))
                 }
                 val py = Python.getInstance()
                 val mainScript = py.getModule("main_script")
-                val result = mainScript.callAttr("update_character_data", context.filesDir.absolutePath).asList()
-                val status = result[0].toString() // SUCCESS, SKIPPED, FAILED
+                val result = mainScript.callAttr("update_character_data", context.filesDir.absolutePath, quality).asList()
+                val resultStatus = result[0].toString() // SUCCESS, SKIPPED, FAILED
                 val message = result[1].toString()
 
-                when (status) {
+                when (resultStatus) {
                     "SUCCESS" -> {
                         println("Successfully ran scraper and saved characters.json: $message")
                         // When a new characters.json is generated, the mod cache becomes invalid.
@@ -39,27 +45,31 @@ class CharacterRepository(private val context: Context) {
                             cacheFile.delete()
                             println("Deleted mod cache to force re-scan.")
                         }
-                        success = true
+                        status = "SUCCESS"
                     }
                     "SKIPPED" -> {
                         println("Scraper skipped: $message")
-                        success = true
+                        status = "SKIPPED"
                     }
                     "FAILED" -> {
                         println("Scraper script failed: $message. Will use local version if available.")
-                        success = false
+                        status = "FAILED"
                     }
                 }
             } catch (e: Exception) {
                 e.printStackTrace()
                 println("Failed to execute scraper python script, will use local version. Error: ${e.message}")
-                success = false
+                status = "FAILED"
             }
             characterLut = parseCharacterJson()
-            success
+            status
         }
     }
 
+    fun hasLocalCharactersJson(): Boolean {
+        return File(context.filesDir, CHARACTERS_JSON_FILENAME).exists()
+    }
+
     private suspend fun parseCharacterJson(): Map<String, List<CharacterInfo>> {
         return withContext(Dispatchers.IO) {
             val lut = mutableMapOf<String, MutableList<CharacterInfo>>()

app/src/main/java/com/example/bd2modmanager/data/repository/ModRepository.kt

@@ -2,7 +2,7 @@ package com.example.bd2modmanager.data.repository
 
 import android.content.Context
 import android.net.Uri
-import androidx.documentfile.provider.DocumentFile
+import android.provider.DocumentsContract
 import com.chaquo.python.Python
 import com.example.bd2modmanager.data.model.MatchStrategy
 import com.example.bd2modmanager.data.model.ModCacheInfo
@@ -51,12 +51,36 @@ class ModRepository(
             val newCache = mutableMapOf<String, ModCacheInfo>()
             val tempModsList = mutableListOf<ModInfo>()
             val candidates = mutableListOf<ScannedModCandidate>()
-            val files = DocumentFile.fromTreeUri(context, dirUri)?.listFiles() ?: emptyArray()
 
-            files.filter { it.isDirectory || it.name?.endsWith(".zip", ignoreCase = true) == true }
-                .forEach { file ->
-                    val uriString = file.uri.toString()
-                    val lastModified = file.lastModified()
+            // Single ContentResolver query replaces DocumentFile.listFiles() + per-file queries.
+            // DocumentFile does O(n*k) queries; this does O(1) regardless of file count.
+            val treeDocId = DocumentsContract.getTreeDocumentId(dirUri)
+            val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(dirUri, treeDocId)
+            val projection = arrayOf(
+                DocumentsContract.Document.COLUMN_DOCUMENT_ID,
+                DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+                DocumentsContract.Document.COLUMN_MIME_TYPE,
+                DocumentsContract.Document.COLUMN_LAST_MODIFIED
+            )
+
+            context.contentResolver.query(childrenUri, projection, null, null, null)?.use { cursor ->
+                val idCol = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_DOCUMENT_ID)
+                val nameCol = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_DISPLAY_NAME)
+                val mimeCol = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_MIME_TYPE)
+                val modifiedCol = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_LAST_MODIFIED)
+
+                while (cursor.moveToNext()) {
+                    val documentId = cursor.getString(idCol) ?: continue
+                    val displayName = cursor.getString(nameCol) ?: continue
+                    val mimeType = cursor.getString(mimeCol) ?: ""
+                    val lastModified = cursor.getLong(modifiedCol)
+
+                    val isDirectory = mimeType == DocumentsContract.Document.MIME_TYPE_DIR
+                    val isZip = displayName.endsWith(".zip", ignoreCase = true)
+                    if (!isDirectory && !isZip) continue
+
+                    val fileUri = DocumentsContract.buildDocumentUriUsingTree(dirUri, documentId)
+                    val uriString = fileUri.toString()
                     val cachedInfo = existingCache[uriString]
 
                     if (cachedInfo != null && cachedInfo.lastModified == lastModified) {
@@ -68,7 +92,7 @@ class ModRepository(
                                 costume = cachedInfo.costume,
                                 type = cachedInfo.type,
                                 isEnabled = false,
-                                uri = file.uri,
+                                uri = fileUri,
                                 targetHashedName = cachedInfo.targetHashedName,
                                 isDirectory = cachedInfo.isDirectory,
                                 resolutionState = cachedInfo.resolutionState,
@@ -79,25 +103,25 @@ class ModRepository(
                             )
                         )
                     } else {
-                        val modName = file.name?.removeSuffix(".zip") ?: ""
-                        val isDirectory = file.isDirectory
+                        val modName = displayName.removeSuffix(".zip")
                         val modDetails = if (isDirectory) {
-                            extractModDetailsFromDirectory(file.uri)
+                            extractModDetailsFromDirectory(fileUri)
                         } else {
-                            extractModDetailsFromUri(file.uri)
+                            extractModDetailsFromUri(fileUri)
                         }
                         candidates.add(
                             ScannedModCandidate(
                                 uriString = uriString,
                                 lastModified = lastModified,
                                 name = modName,
-                                uri = file.uri,
+                                uri = fileUri,
                                 isDirectory = isDirectory,
                                 modDetails = modDetails
                             )
                         )
                     }
                 }
+            }
 
             if (candidates.isNotEmpty()) {
                 if (!Python.isStarted()) {
@@ -113,10 +137,13 @@ class ModRepository(
                     }
                 }
 
+                val prefs = context.getSharedPreferences("app_settings", android.content.Context.MODE_PRIVATE)
+                val selectedQuality = prefs.getString("selected_quality", "HD") ?: "HD"
+
                 val (batchSuccess, batchResults) = ModdingService.resolveModBatch(
                     batchPayload.toString(),
                     context.filesDir.absolutePath,
-                    "HD"
+                    selectedQuality
                 ) { }
 
                 val resultsById = mutableMapOf<Int, JSONObject>()
@@ -217,6 +244,12 @@ class ModRepository(
         val cacheFile = getModCacheFile()
         if (!cacheFile.exists()) return emptyMap()
 
+        val indexFile = File(context.filesDir, "local_bundle_index.json")
+        if (indexFile.exists() && indexFile.lastModified() > cacheFile.lastModified()) {
+            // Unify: If the bundle index updated, all mod cache entries are potentially stale
+            return emptyMap()
+        }
+
         return try {
             val json = cacheFile.readText()
             val type = object : TypeToken<Map<String, ModCacheInfo>>() {}.type
@@ -263,12 +296,24 @@ class ModRepository(
         val fileNames = mutableListOf<String>()
         var fileId: String? = null
         try {
-            DocumentFile.fromTreeUri(context, dirUri)?.listFiles()?.forEach { file ->
-                val entryName = file.name ?: ""
-                if (shouldIgnoreModEntry(entryName)) return@forEach
-                fileNames.add(entryName)
-                if (file.isFile) {
-                    if (fileId == null) fileId = characterRepository.extractFileId(entryName)
+            val docId = DocumentsContract.getDocumentId(dirUri)
+            val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(dirUri, docId)
+            val projection = arrayOf(
+                DocumentsContract.Document.COLUMN_DISPLAY_NAME,
+                DocumentsContract.Document.COLUMN_MIME_TYPE
+            )
+            context.contentResolver.query(childrenUri, projection, null, null, null)?.use { cursor ->
+                val nameCol = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_DISPLAY_NAME)
+                val mimeCol = cursor.getColumnIndexOrThrow(DocumentsContract.Document.COLUMN_MIME_TYPE)
+                while (cursor.moveToNext()) {
+                    val entryName = cursor.getString(nameCol) ?: continue
+                    val mimeType = cursor.getString(mimeCol) ?: ""
+                    if (shouldIgnoreModEntry(entryName)) continue
+                    fileNames.add(entryName)
+                    val isFile = mimeType != DocumentsContract.Document.MIME_TYPE_DIR
+                    if (isFile && fileId == null) {
+                        fileId = characterRepository.extractFileId(entryName)
+                    }
                 }
             }
         } catch (e: Exception) {

app/src/main/java/com/example/bd2modmanager/service/ModdingService.kt

@@ -139,4 +139,68 @@ object ModdingService {
             Pair(false, e.message ?: "An unknown error occurred in Kotlin during spine merge.")
         }
     }
+
+    // --- Local bundle scanning (three-step API) ---
+
+    fun checkScanNeeded(outputDir: String, bundleListJson: String, onProgress: (String) -> Unit): String {
+        return try {
+            val py = Python.getInstance()
+            val mainScript = py.getModule("main_script")
+
+            val result = mainScript.callAttr(
+                "check_scan_needed",
+                outputDir,
+                bundleListJson,
+                PyObject.fromJava(onProgress)
+            ).toString()
+
+            result
+        } catch (e: Exception) {
+            e.printStackTrace()
+            "[]"
+        }
+    }
+
+    fun scanSingleBundle(bundleName: String, bundleHash: String, tempDataPath: String, onProgress: (String) -> Unit): Triple<Boolean, Int, String> {
+        return try {
+            val py = Python.getInstance()
+            val mainScript = py.getModule("main_script")
+
+            val result = mainScript.callAttr(
+                "scan_single_bundle",
+                bundleName,
+                bundleHash,
+                tempDataPath,
+                PyObject.fromJava(onProgress)
+            ).asList()
+
+            val success = result[0].toBoolean()
+            val assetCount = result[1].toInt()
+            val message = result[2].toString()
+            Triple(success, assetCount, message)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            Triple(false, 0, e.message ?: "Unknown error during bundle scan.")
+        }
+    }
+
+    fun finalizeScan(outputDir: String, onProgress: (String) -> Unit): Pair<Boolean, String> {
+        return try {
+            val py = Python.getInstance()
+            val mainScript = py.getModule("main_script")
+
+            val result = mainScript.callAttr(
+                "finalize_scan",
+                outputDir,
+                PyObject.fromJava(onProgress)
+            ).asList()
+
+            val success = result[0].toBoolean()
+            val message = result[1].toString()
+            Pair(success, message)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            Pair(false, e.message ?: "Unknown error during scan finalization.")
+        }
+    }
 }