remove comment

# app [1.26.0-dev.23](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.22...v1.26.0-dev.23) (2026-02-19)

### Bug Fixes

* Flutter migration ([#2946](https://github.com/ReVanced/revanced-manager/issues/2946)) ([31a0f75](31a0f751aa))

api/build.gradle.kts

@@ -23,6 +23,10 @@ kotlin {
     jvmToolchain(17)
     compilerOptions {
         jvmTarget = JvmTarget.JVM_17
+        freeCompilerArgs.addAll(
+            "-Xexplicit-backing-fields",
+            "-Xcontext-parameters",
+        )
     }
 }
 

app/CHANGELOG.md

@@ -1,3 +1,24 @@
+# app [1.26.0-dev.23](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.22...v1.26.0-dev.23) (2026-02-19)
+
+
+### Bug Fixes
+
+* Flutter migration ([#2946](https://github.com/ReVanced/revanced-manager/issues/2946)) ([31a0f75](https://github.com/ReVanced/revanced-manager/commit/31a0f751aaff3233f50821963f28454d239318b2))
+
+# app [1.26.0-dev.22](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.21...v1.26.0-dev.22) (2026-02-19)
+
+
+### Bug Fixes
+
+* Create modules path in root installer ([4fc2ba3](https://github.com/ReVanced/revanced-manager/commit/4fc2ba339b6d275fb9da8b65ff86b74a6594436d))
+
+# app [1.26.0-dev.21](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.20...v1.26.0-dev.21) (2026-02-19)
+
+
+### Features
+
+* Allow multiple downloaders per APK ([#2916](https://github.com/ReVanced/revanced-manager/issues/2916)) ([0f56377](https://github.com/ReVanced/revanced-manager/commit/0f56377214fae05693a21177daf7534c103df74e))
+
 # app [1.26.0-dev.20](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.19...v1.26.0-dev.20) (2026-01-09)
 
 

app/build.gradle.kts

@@ -135,15 +135,15 @@ android {
     buildToolsVersion = "35.0.1"
 
     defaultConfig {
-        applicationId = "app.revanced.manager"
+        applicationId = "app.revanced.manager.flutter"
         minSdk = 26
         targetSdk = 35
 
         val versionStr = if (version == "unspecified") "1.0.0" else version.toString()
         versionName = versionStr
         versionCode = with(versionStr.toVersion()) {
-            major * 10_000_000 +
-                    minor * 10_000 +
+            major * 100_000_000 +
+                    minor * 100_000 +
                     patch * 100 +
                     (preRelease?.substringAfterLast('.')?.toInt() ?: 99)
         }
@@ -217,23 +217,6 @@ android {
         includeInBundle = false
     }
 
-    packaging {
-        resources.excludes.addAll(
-            listOf(
-                "/prebuilt/**",
-                "META-INF/DEPENDENCIES",
-                "META-INF/**.version",
-                "DebugProbesKt.bin",
-                "kotlin-tooling-metadata.json",
-                "org/bouncycastle/pqc/**.properties",
-                "org/bouncycastle/x509/**.properties",
-            )
-        )
-        jniLibs {
-            useLegacyPackaging = true
-        }
-    }
-
     ksp {
         arg("room.schemaLocation", "$projectDir/schemas")
     }
@@ -254,12 +237,69 @@ android {
             version = "3.22.1"
         }
     }
+
+    packaging {
+        resources {
+            // Useless files
+            excludes += "/XPP3_*_VERSION"
+            excludes += "/font-awesome-license.txt"
+            excludes += "/smali.properties"
+            excludes += "/baksmali.properties"
+            excludes += "/properties/apktool.properties"
+            excludes += "/org/antlr/**"
+            excludes += "/org/mockito/**"
+            excludes += "/org/bouncycastle/pqc/**.properties"
+            excludes += "/org/bouncycastle/x509/**.properties"
+            excludes += "/META-INF/INDEX.LIST"
+            excludes += "/META-INF/**/*.txt"
+            excludes += "/META-INF/**/*.properties"
+            excludes += "/META-INF/DEPENDENCIES"
+
+            // Desktop AAPT binaries
+            excludes += "/prebuilt/**"
+
+            // Reflection symbol list (https://stackoverflow.com/a/41073782/13964629)
+            excludes += "/**/*.kotlin_builtins"
+        }
+        jniLibs {
+            // 32-bit x86 is dead
+            excludes += "/lib/x86/*.so"
+
+            // Equivalent of AndroidManifest's extractNativeLibs=true to ensure libs are compressed
+            useLegacyPackaging = true
+        }
+    }
+}
+
+androidComponents {
+    onVariants(selector().withBuildType("release")) {
+        it.packaging.resources.excludes.apply {
+            // Debug metadata
+            add("/META-INF/*.version")
+            add("/META-INF/*.kotlin_module")
+            add("/kotlin-tooling-metadata.json")
+
+            // Kotlin debugging (https://github.com/Kotlin/kotlinx.coroutines/issues/2274)
+            add("/DebugProbesKt.bin")
+        }
+    }
 }
 
 kotlin {
     jvmToolchain(17)
     compilerOptions {
         jvmTarget = JvmTarget.JVM_17
+        freeCompilerArgs.addAll(
+            "-Xexplicit-backing-fields",
+            "-Xcontext-parameters",
+        )
+    }
+}
+
+configurations {
+    all {
+        // ReVanced Library has a dependency which conflicts with whatever this is. We don't use protobuf, so it should be fine.
+        exclude(group = "com.google.api.grpc", module = "proto-google-common-protos")
     }
 }
 

app/gradle.properties

@@ -1 +1 @@
-version = 1.26.0-dev.20
+version = 1.26.0-dev.23

app/src/main/java/app/revanced/manager/MainActivity.kt

@@ -1,12 +1,9 @@
 package app.revanced.manager
 
-import android.content.ActivityNotFoundException
 import android.os.Bundle
 import android.os.Parcelable
-import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.animation.ExperimentalAnimationApi
 import androidx.compose.animation.slideInHorizontally
@@ -62,6 +59,7 @@ import org.koin.androidx.compose.koinViewModel
 import org.koin.core.parameter.parametersOf
 import org.koin.androidx.viewmodel.ext.android.getViewModel as getActivityViewModel
 
+
 class MainActivity : AppCompatActivity() {
     @ExperimentalAnimationApi
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -74,21 +72,10 @@ class MainActivity : AppCompatActivity() {
         val vm: MainViewModel = getActivityViewModel()
 
         setContent {
-            val launcher = rememberLauncherForActivityResult(
-                ActivityResultContracts.StartActivityForResult(),
-                onResult = vm::applyLegacySettings
-            )
             val theme by vm.prefs.theme.getAsState()
             val dynamicColor by vm.prefs.dynamicColor.getAsState()
             val pureBlackTheme by vm.prefs.pureBlackTheme.getAsState()
 
-            EventEffect(vm.legacyImportActivityFlow) {
-                try {
-                    launcher.launch(it)
-                } catch (_: ActivityNotFoundException) {
-                }
-            }
-
             ReVancedManagerTheme(
                 darkTheme = theme == Theme.SYSTEM && isSystemInDarkTheme() || theme == Theme.DARK,
                 dynamicColor = dynamicColor,

app/src/main/java/app/revanced/manager/data/room/options/Option.kt

@@ -5,8 +5,6 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 import app.revanced.manager.patcher.patch.Option
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.SerializationException
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonNull
@@ -36,7 +34,7 @@ import kotlin.reflect.typeOf
 data class Option(
     @ColumnInfo(name = "group") val group: Int,
     @ColumnInfo(name = "patch_name") val patchName: String,
-    @ColumnInfo(name = "key") val key: String,
+    @ColumnInfo(name = "key") val name: String,
     // Encoded as Json.
     @ColumnInfo(name = "value") val value: SerializedValue,
 ) {

app/src/main/java/app/revanced/manager/domain/installer/RootInstaller.kt

@@ -121,7 +121,7 @@ class RootInstaller(
             execute("pm install \"${stockApp.absolutePath}\"").assertSuccess("Failed to install stock app")
         }
 
-        remoteFS.getFile(modulePath).mkdir()
+        remoteFS.getFile(modulePath).mkdirs()
 
         listOf(
             "service.sh",

app/src/main/java/app/revanced/manager/domain/repository/PatchBundleRepository.kt

@@ -38,6 +38,7 @@ import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.withContext
 import java.io.InputStream
 import kotlin.collections.joinToString
@@ -115,32 +116,18 @@ class PatchBundleRepository(
             Log.d(tag, "Bundle: $it")
         }
 
-        val sources = entities.associate { it.uid to it.load() }.toPersistentMap()
+        val sources = entities
+            .associateTo(mutableMapOf()) { it.uid to it.load() }
+        sources.forEach syncName@{ (uid, src) ->
+            val newName = src.patchBundle?.manifestAttributes?.name?.takeIf { it != src.name }
+                ?: return@syncName
 
-        val hasOutOfDateNames = sources.values.any { it.isNameOutOfDate }
-        if (hasOutOfDateNames) dispatchAction(
-            "Sync names"
-        ) { state ->
-            val nameChanges = state.sources.mapNotNull { (_, src) ->
-                if (!src.isNameOutOfDate) return@mapNotNull null
-                val newName = src.patchBundle?.manifestAttributes?.name?.takeIf { it != src.name }
-                    ?: return@mapNotNull null
-
-                src.uid to newName
-            }
-            val sources = state.sources.toMutableMap()
-            val info = state.info.toMutableMap()
-            nameChanges.forEach { (uid, name) ->
-                updateDb(uid) { it.copy(name = name) }
-                sources[uid] = sources[uid]!!.copy(name = name)
-                info[uid] = info[uid]?.copy(name = name) ?: return@forEach
-            }
-
-            State(sources.toPersistentMap(), info.toPersistentMap())
+            updateDb(uid) { it.copy(name = newName) }
+            sources[uid] = src.copy(name = newName)
         }
-        val info = loadMetadata(sources).toPersistentMap()
 
-        return State(sources, info)
+        val info = loadMetadata(sources).toPersistentMap()
+        return State(sources.toPersistentMap(), info)
     }
 
     suspend fun reload() = dispatchAction("Full reload") {
@@ -157,38 +144,46 @@ class PatchBundleRepository(
         return all
     }
 
-    private suspend fun loadMetadata(sources: Map<Int, PatchBundleSource>): Map<Int, PatchBundleInfo.Global> {
+    private suspend fun loadMetadata(sources: MutableMap<Int, PatchBundleSource>): Map<Int, PatchBundleInfo.Global> {
         // Map bundles -> sources
         val map = sources.mapNotNull { (_, src) ->
             (src.patchBundle ?: return@mapNotNull null) to src
         }.toMap()
 
         val metadata = try {
-            PatchBundle.Loader.metadata(map.keys)
+            runInterruptible(Dispatchers.Default) {
+                PatchBundle.Loader.metadata(map.keys)
+            }
+        } catch (e: CancellationException) {
+            throw e
         } catch (error: Throwable) {
-            val uids = map.values.map { it.uid }
-
-            dispatchAction("Mark bundles as failed") { state ->
-                state.copy(sources = state.sources.mutate {
-                    uids.forEach { uid ->
-                        it[uid] = it[uid]?.copy(error = error) ?: return@forEach
-                    }
-                })
+            sources.entries.forEach { entry ->
+                entry.setValue(entry.value.copy(error = error))
             }
 
             Log.e(tag, "Failed to load bundles", error)
             emptyMap()
         }
 
-        return metadata.entries.associate { (bundle, patches) ->
-            val src = map[bundle]!!
-            src.uid to PatchBundleInfo.Global(
-                src.name,
-                bundle.manifestAttributes?.version,
-                src.uid,
-                patches
-            )
+        val output = buildMap {
+            metadata.forEach { (bundle, result) ->
+                val src = map[bundle]!!
+                val error = result.exceptionOrNull()
+                if (error != null) {
+                    sources[src.uid] = src.copy(error = error)
+                    return@forEach
+                }
+
+                this[src.uid] = PatchBundleInfo.Global(
+                    src.name,
+                    bundle.manifestAttributes?.version,
+                    src.uid,
+                    result.getOrThrow().toList()
+                )
+            }
         }
+
+        return output
     }
 
     suspend fun isVersionAllowed(packageName: String, version: String) =
@@ -313,9 +308,9 @@ class PatchBundleRepository(
         }
 
     suspend fun reloadApiBundles() = dispatchAction("Reload API bundles") {
-        this@PatchBundleRepository.sources.first().filterIsInstance<APIPatchBundle>().forEach {
-            with(it) { deleteLocalFile() }
-            updateDb(it.uid) { it.copy(versionHash = null) }
+        this@PatchBundleRepository.sources.first().filterIsInstance<APIPatchBundle>().forEach { src ->
+            with(src) { deleteLocalFile() }
+            updateDb(src.uid) { it.copy(versionHash = null) }
         }
 
         doReload()

app/src/main/java/app/revanced/manager/domain/repository/PatchOptionsRepository.kt

@@ -35,15 +35,15 @@ class PatchOptionsRepository(db: AppDatabase) {
                             bundlePatchOptions.getOrPut(dbOption.patchName, ::mutableMapOf)
 
                         val option =
-                            bundlePatches[sourceUid]?.get(dbOption.patchName)?.options?.find { it.key == dbOption.key }
+                            bundlePatches[sourceUid]?.get(dbOption.patchName)?.options?.find { it.name == dbOption.name }
                         if (option != null) {
                             try {
-                                deserializedPatchOptions[option.key] =
+                                deserializedPatchOptions[option.name] =
                                     dbOption.value.deserializeFor(option)
                             } catch (e: Option.SerializationException) {
                                 Log.w(
                                     tag,
-                                    "Option ${dbOption.patchName}:${option.key} could not be deserialized",
+                                    "Option ${dbOption.patchName}:${option.name} could not be deserialized",
                                     e
                                 )
                             }

app/src/main/java/app/revanced/manager/patcher/Session.kt

@@ -4,66 +4,71 @@ import app.revanced.library.ApkUtils.applyTo
 import app.revanced.manager.patcher.Session.Companion.component1
 import app.revanced.manager.patcher.Session.Companion.component2
 import app.revanced.manager.patcher.logger.Logger
-import app.revanced.patcher.Patcher
-import app.revanced.patcher.PatcherConfig
+import app.revanced.patcher.PatchesResult
 import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.patch.PatchResult
+import app.revanced.patcher.patcher
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.withContext
 import java.io.Closeable
 import java.io.File
 import java.nio.file.Files
 import java.nio.file.StandardCopyOption
 
-internal typealias PatchList = List<Patch<*>>
+internal typealias PatchList = List<Patch>
+private typealias Patcher = (emit: (PatchResult) -> Unit) -> PatchesResult
 
 class Session(
     cacheDir: String,
-    frameworkDir: String,
-    aaptPath: String,
+    private val frameworkDir: String,
+    private val aaptPath: String,
     private val logger: Logger,
     private val input: File,
     private val onEvent: (ProgressEvent) -> Unit,
 ) : Closeable {
     private val tempDir = File(cacheDir).resolve("patcher").also { it.mkdirs() }
-    private val patcher = Patcher(
-        PatcherConfig(
-            apkFile = input,
-            temporaryFilesPath = tempDir,
-            frameworkFileDirectory = frameworkDir,
-            aaptBinaryPath = aaptPath
-        )
-    )
 
-    private suspend fun Patcher.applyPatchesVerbose(selectedPatches: PatchList) {
-        this().collect { (patch, exception) ->
-            val index = selectedPatches.indexOf(patch)
-            if (index == -1) return@collect
 
-            if (exception != null) {
+    private suspend fun applyPatchesVerbose(patcher: Patcher, indices: Map<Patch, Int>) =
+        withContext(
+            Dispatchers.Default
+        ) {
+            val context = currentCoroutineContext()
+            patcher { (patch, exception) ->
+                // Make the patching process cancelable.
+                context.ensureActive()
+
+                val index = indices[patch] ?: return@patcher
+
+                if (exception != null) {
+                    onEvent(
+                        ProgressEvent.Failed(
+                            StepId.ExecutePatch(index),
+                            exception.toRemoteError(),
+                        )
+                    )
+                    logger.error("${patch.name} failed:")
+                    logger.error(exception.stackTraceToString())
+                    throw exception
+                }
+
                 onEvent(
-                    ProgressEvent.Failed(
+                    ProgressEvent.Completed(
                         StepId.ExecutePatch(index),
-                        exception.toRemoteError(),
                     )
                 )
-                logger.error("${patch.name} failed:")
-                logger.error(exception.stackTraceToString())
-                throw exception
+
+                logger.info("${patch.name} succeeded")
             }
-
-            onEvent(
-                ProgressEvent.Completed(
-                    StepId.ExecutePatch(index),
-                )
-            )
-
-            logger.info("${patch.name} succeeded")
         }
-    }
 
     suspend fun run(output: File, selectedPatches: PatchList) {
-        runStep(StepId.ExecutePatches, onEvent) {
+        val indices = HashMap<Patch, Int>(selectedPatches.size)
+        selectedPatches.forEachIndexed { idx, patch -> indices[patch] = idx }
+
+        val result = runStep(StepId.ExecutePatches, onEvent) {
             java.util.logging.Logger.getLogger("").apply {
                 handlers.forEach {
                     it.close()
@@ -73,18 +78,21 @@ class Session(
                 addHandler(logger.handler)
             }
 
-            with(patcher) {
-                logger.info("Merging integrations")
-                this += selectedPatches.toSet()
-
-                logger.info("Applying patches...")
-                applyPatchesVerbose(selectedPatches.sortedBy { it.name })
+            val patcher = patcher(
+                apkFile = input,
+                temporaryFilesPath = tempDir,
+                frameworkFileDirectory = frameworkDir,
+                aaptBinaryPath = File(aaptPath)
+            ) { _packageName, _version ->
+                selectedPatches.toSet()
             }
+
+            logger.info("Applying patches...")
+            applyPatchesVerbose(patcher, indices)
         }
 
         runStep(StepId.WriteAPK, onEvent) {
             logger.info("Writing patched files...")
-            val result = patcher.get()
 
             val patched = tempDir.resolve("result.apk")
             withContext(Dispatchers.IO) {
@@ -102,7 +110,6 @@ class Session(
 
     override fun close() {
         tempDir.deleteRecursively()
-        patcher.close()
     }
 
     companion object {

app/src/main/java/app/revanced/manager/patcher/patch/PatchBundle.kt

@@ -2,7 +2,8 @@ package app.revanced.manager.patcher.patch
 
 import kotlinx.parcelize.IgnoredOnParcel
 import android.os.Parcelable
-import app.revanced.patcher.patch.loadPatchesFromDex
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.loadPatches
 import kotlinx.parcelize.Parcelize
 import java.io.File
 import java.io.IOException
@@ -54,31 +55,45 @@ data class PatchBundle(val patchesJar: String) : Parcelable {
     )
 
     object Loader {
-        private fun patches(bundles: Iterable<PatchBundle>) =
-            loadPatchesFromDex(
-                bundles.map { File(it.patchesJar) }.toSet()
-            ).byPatchesFile.mapKeys { (file, _) ->
-                val absPath = file.absolutePath
-                bundles.single { absPath == it.patchesJar }
+        private fun patches(bundles: Iterable<PatchBundle>) = buildMap {
+            val bundleMap = bundles.associateBy { it.patchesJar }
+
+            loadPatches(
+                *bundleMap.keys.map(::File).toTypedArray(),
+                onFailedToLoad = { file, throwable ->
+                    this[bundleMap[file.absolutePath]!!] = Result.failure(throwable)
+                }
+            ).patchesByFile.forEach { (file, patches) ->
+                putIfAbsent(bundleMap[file.absolutePath]!!, Result.success(patches))
+            }
+        }
+
+        fun metadata(bundles: Iterable<PatchBundle>): Map<PatchBundle, Result<Set<PatchInfo>>> =
+            patches(bundles).mapValues { (_, result) ->
+                result.map { patches ->
+                    patches.mapTo(
+                        HashSet(patches.size),
+                        ::PatchInfo
+                    )
+                }
             }
 
-        fun metadata(bundles: Iterable<PatchBundle>) =
-            patches(bundles).mapValues { (_, patches) -> patches.map(::PatchInfo) }
+        fun patches(bundles: Iterable<PatchBundle>, packageName: String): Map<PatchBundle, Set<Patch>> =
+            patches(bundles).mapValues { (_, result) ->
+                val patches = result.getOrDefault(emptySet())
 
-        fun patches(bundles: Iterable<PatchBundle>, packageName: String) =
-            patches(bundles).mapValues { (_, patches) ->
-                patches.filter { patch ->
+                patches.filterTo(HashSet(patches.size)) { patch ->
                     val compatiblePackages = patch.compatiblePackages
                         ?: // The patch has no compatibility constraints, which means it is universal.
-                        return@filter true
+                        return@filterTo true
 
                     if (!compatiblePackages.any { (name, _) -> name == packageName }) {
                         // Patch is not compatible with this package.
-                        return@filter false
+                        return@filterTo false
                     }
 
                     true
-                }.toSet()
+                }
             }
     }
-}
+}

app/src/main/java/app/revanced/manager/patcher/patch/PatchBundleInfo.kt

@@ -137,7 +137,7 @@ sealed class PatchBundleInfo {
                     it.options.all option@{ option ->
                         if (!option.required || option.default != null) return@option true
 
-                        option.key in opts
+                        option.name in opts
                     }
                 }
         }

app/src/main/java/app/revanced/manager/patcher/patch/PatchInfo.kt

@@ -17,7 +17,7 @@ data class PatchInfo(
     val compatiblePackages: ImmutableList<CompatiblePackage>?,
     val options: ImmutableList<Option<*>>?
 ) {
-    constructor(patch: Patch<*>) : this(
+    constructor(patch: Patch) : this(
         patch.name.orEmpty(),
         patch.description,
         patch.use,
@@ -49,7 +49,7 @@ data class PatchInfo(
      * The resulting patch cannot be executed.
      * This is necessary because some functions in ReVanced Library only accept full [Patch] objects.
      */
-    fun toPatcherPatch(): Patch<*> =
+    fun toPatcherPatch(): Patch =
         resourcePatch(name = name, description = description, use = include) {
             compatiblePackages?.let { pkgs ->
                 compatibleWith(*pkgs.map { it.packageName to it.versions }.toTypedArray())
@@ -65,8 +65,7 @@ data class CompatiblePackage(
 
 @Immutable
 data class Option<T>(
-    val title: String,
-    val key: String,
+    val name: String,
     val description: String,
     val required: Boolean,
     val type: KType,
@@ -75,8 +74,7 @@ data class Option<T>(
     val validator: (T?) -> Boolean,
 ) {
     constructor(option: PatchOption<T>) : this(
-        option.title ?: option.key,
-        option.key,
+        option.name,
         option.description.orEmpty(),
         option.required,
         option.type,

app/src/main/java/app/revanced/manager/ui/component/bundle/BundlePatchesDialog.kt

@@ -212,7 +212,7 @@ fun PatchItem(
                                     verticalArrangement = Arrangement.spacedBy(4.dp),
                                 ) {
                                     Text(
-                                        text = option.title,
+                                        text = option.name,
                                         style = MaterialTheme.typography.titleMedium,
                                         color = MaterialTheme.colorScheme.primary
                                     )

app/src/main/java/app/revanced/manager/ui/component/patches/OptionFields.kt

@@ -205,7 +205,7 @@ fun <T : Any> OptionItem(
     WithOptionEditor(editor, option, value, setValue, selectionWarningEnabled) {
         ListItem(
             modifier = Modifier.clickable(onClick = ::clickAction),
-            headlineContent = { Text(option.title) },
+            headlineContent = { Text(option.name) },
             supportingContent = {
                 Column {
                     Text(option.description)
@@ -250,7 +250,7 @@ private object StringOptionEditor : OptionEditor<String> {
 
         AlertDialog(
             onDismissRequest = scope.dismissDialog,
-            title = { Text(scope.option.title) },
+            title = { Text(scope.option.name) },
             text = {
                 OutlinedTextField(
                     value = fieldValue,
@@ -330,7 +330,7 @@ private abstract class NumberOptionEditor<T : Number> : OptionEditor<T> {
 
     @Composable
     override fun Dialog(scope: OptionEditorScope<T>) {
-        NumberDialog(scope.option.title, scope.value, scope.option.validator) {
+        NumberDialog(scope.option.name, scope.value, scope.option.validator) {
             if (it == null) return@NumberDialog scope.dismissDialog()
 
             scope.submitDialog(it)
@@ -455,7 +455,7 @@ private class PresetOptionEditor<T : Any>(private val innerEditor: OptionEditor<
                         Text(stringResource(R.string.cancel))
                     }
                 },
-                title = { Text(scope.option.title) },
+                title = { Text(scope.option.name) },
                 textHorizontalPadding = PaddingValues(horizontal = 0.dp),
                 text = {
                     val presets = remember(scope.option.presets) {
@@ -496,8 +496,7 @@ private class PresetOptionEditor<T : Any>(private val innerEditor: OptionEditor<
 private class ListOptionEditor<T : Serializable>(private val elementEditor: OptionEditor<T>) :
     OptionEditor<List<T>> {
     private fun createElementOption(option: Option<List<T>>) = Option<T>(
-        option.title,
-        option.key,
+        option.name,
         option.description,
         option.required,
         option.type.arguments.first().type!!,
@@ -566,7 +565,7 @@ private class ListOptionEditor<T : Serializable>(private val elementEditor: Opti
                             R.plurals.selected_count,
                             deletionTargets.size,
                             deletionTargets.size
-                        ) else scope.option.title,
+                        ) else scope.option.name,
                         onBackClick = back,
                         backIcon = {
                             if (deleteMode) {

app/src/main/java/app/revanced/manager/ui/screen/PatchesSelectorScreen.kt

@@ -640,17 +640,17 @@ private fun OptionsDialog(
         ) {
             if (patch.options == null) return@LazyColumnWithScrollbar
 
-            items(patch.options, key = { it.key }) { option ->
-                val key = option.key
+            items(patch.options, key = { it.name }) { option ->
+                val name = option.name
                 val value =
-                    if (values == null || !values.contains(key)) option.default else values[key]
+                    if (values == null || !values.contains(name)) option.default else values[name]
 
                 @Suppress("UNCHECKED_CAST")
                 OptionItem(
                     option = option as Option<Any>,
                     value = value,
                     setValue = {
-                        set(key, it)
+                        set(name, it)
                     },
                     selectionWarningEnabled = selectionWarningEnabled
                 )

app/src/main/java/app/revanced/manager/ui/screen/RequiredOptionsScreen.kt

@@ -144,16 +144,16 @@ fun RequiredOptionsScreen(
 
                             val values = vm.getOptions(bundle.uid, it)
                             it.options?.forEach { option ->
-                                val key = option.key
+                                val name = option.name
                                 val value =
-                                    if (values == null || key !in values) option.default else values[key]
+                                    if (values == null || name !in values) option.default else values[name]
 
                                 @Suppress("UNCHECKED_CAST")
                                 OptionItem(
                                     option = option as Option<Any>,
                                     value = value,
                                     setValue = { new ->
-                                        vm.setOption(bundle.uid, it, key, new)
+                                        vm.setOption(bundle.uid, it, name, new)
                                     },
                                     selectionWarningEnabled = vm.selectionWarningEnabled
                                 )

app/src/main/java/app/revanced/manager/ui/viewmodel/MainViewModel.kt

@@ -1,18 +1,19 @@
 package app.revanced.manager.ui.viewmodel
 
-import android.app.Activity
 import android.app.Application
-import android.content.Intent
-import android.util.Base64
+import android.content.Context.MODE_PRIVATE
+import android.content.SharedPreferences
 import android.util.Log
-import androidx.activity.result.ActivityResult
+import androidx.core.content.edit
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.revanced.manager.R
+import app.revanced.manager.data.room.apps.installed.InstallType
 import app.revanced.manager.domain.bundles.PatchBundleSource.Extensions.asRemoteOrNull
 import app.revanced.manager.domain.manager.KeystoreManager
 import app.revanced.manager.domain.manager.PreferencesManager
 import app.revanced.manager.domain.repository.DownloadedAppRepository
+import app.revanced.manager.domain.repository.InstalledAppRepository
 import app.revanced.manager.domain.repository.PatchBundleRepository
 import app.revanced.manager.domain.repository.PatchSelectionRepository
 import app.revanced.manager.domain.repository.SerializedSelection
@@ -27,11 +28,16 @@ import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.json.Json
+import org.json.JSONObject
+import java.io.File
+
+private const val LEGACY_LIST_PREFIX = "VGhpcyBpcyB0aGUgcHJlZml4IGZvciBhIGxpc3Qu!"
 
 class MainViewModel(
     private val patchBundleRepository: PatchBundleRepository,
     private val patchSelectionRepository: PatchSelectionRepository,
     private val downloadedAppRepository: DownloadedAppRepository,
+    private val installedAppRepository: InstalledAppRepository,
     private val keystoreManager: KeystoreManager,
     private val app: Application,
     val prefs: PreferencesManager,
@@ -39,8 +45,6 @@ class MainViewModel(
 ) : ViewModel() {
     private val appSelectChannel = Channel<SelectedApp>()
     val appSelectFlow = appSelectChannel.receiveAsFlow()
-    private val legacyImportActivityChannel = Channel<Intent>()
-    val legacyImportActivityFlow = legacyImportActivityChannel.receiveAsFlow()
 
     private suspend fun suggestedVersion(packageName: String) =
         patchBundleRepository.suggestedVersions.first()[packageName]
@@ -72,43 +76,55 @@ class MainViewModel(
     init {
         viewModelScope.launch {
             if (!prefs.firstLaunch.get()) return@launch
-            legacyImportActivityChannel.send(Intent().apply {
-                setClassName(
-                    "app.revanced.manager.flutter",
-                    "app.revanced.manager.flutter.ExportSettingsActivity"
-                )
-            })
+            val flutterPrefs = app.getSharedPreferences("FlutterSharedPreferences", MODE_PRIVATE)
+            if (flutterPrefs.all.isNotEmpty()) applyLegacySettings(flutterPrefs)
         }
     }
 
-    fun applyLegacySettings(result: ActivityResult) {
-        if (result.resultCode != Activity.RESULT_OK) {
-            app.toast(app.getString(R.string.legacy_import_failed))
-            Log.e(
-                tag,
-                "Got unknown result code while importing legacy settings: ${result.resultCode}"
-            )
-            return
+    fun applyLegacySettings(flutterPrefs: SharedPreferences) {
+        Log.d(tag, "Migrating flutter preferences")
+        val data = JSONObject().apply {
+            put("keystorePassword", "s3cur3p@ssw0rd")
+
+            val allEntries: Map<String, *> = flutterPrefs.all
+            for ((key, value) in allEntries) {
+                put(key.replace("flutter.", ""), value)
+            }
         }
 
-        val jsonStr = result.data?.getStringExtra("data")
-        if (jsonStr == null) {
-            app.toast(app.getString(R.string.legacy_import_failed))
-            Log.e(tag, "Legacy settings data is null")
-            return
+        val storedPatchesFile = File(app.filesDir.parentFile.absolutePath, "/app_flutter/selected-patches.json")
+        val patches: SerializedSelection? =
+            if (storedPatchesFile.exists()) {
+                json.decodeFromString<SerializedSelection>(storedPatchesFile.readText())
+            } else {
+                null
+            }
+
+        val keystoreFile = File(app.getExternalFilesDir(null), "/revanced-manager.keystore")
+        val keystore: ByteArray? = if (keystoreFile.exists()) {
+            val bytes = keystoreFile.readBytes()
+
+            keystoreFile.delete()
+
+            bytes
+        } else {
+            null
         }
+
+        flutterPrefs.edit(commit = true) { clear() }
+
         val settings = try {
-            json.decodeFromString<LegacySettings>(jsonStr)
+            json.decodeFromString<LegacySettings>(data.toString())
         } catch (e: SerializationException) {
             app.toast(app.getString(R.string.legacy_import_failed))
             Log.e(tag, "Legacy settings data could not be deserialized", e)
             return
         }
 
-        applyLegacySettings(settings)
+        applyLegacySettings(settings, patches, keystore)
     }
 
-    private fun applyLegacySettings(settings: LegacySettings) = viewModelScope.launch {
+    private fun applyLegacySettings(settings: LegacySettings, patches: SerializedSelection?, keystore: ByteArray?) = viewModelScope.launch {
         settings.themeMode?.let { theme ->
             val themeMap = mapOf(
                 0 to Theme.SYSTEM,
@@ -144,20 +160,39 @@ class MainViewModel(
         settings.patchesChangeEnabled?.let { disableSelectionWarning ->
             prefs.disableSelectionWarning.update(disableSelectionWarning)
         }
-        settings.keystore?.let { keystore ->
-            val keystoreBytes = Base64.decode(keystore, Base64.DEFAULT)
+        keystore?.let { keystoreBytes ->
             keystoreManager.import(
                 "alias",
                 settings.keystorePassword,
                 keystoreBytes.inputStream()
             )
         }
-        settings.patches?.let { selection ->
+        patches?.let { selection ->
             patchSelectionRepository.import(0, selection)
         }
+        settings.patchedApps?.let { apps ->
+            json.decodeFromString<List<String>>(apps.removePrefix(LEGACY_LIST_PREFIX)).forEach { appJson ->
+                val patchedApp = json.decodeFromString<LegacyPatchedApp>(appJson)
+                installedAppRepository.addOrUpdate(
+                    patchedApp.packageName,
+                    patchedApp.packageName,
+                    patchedApp.version,
+                    if (patchedApp.isRooted) InstallType.MOUNT else InstallType.DEFAULT,
+                    mapOf(0 to patchedApp.appliedPatches.toSet())
+                )
+            }
+        }
         Log.d(tag, "Imported legacy settings")
     }
 
+    @Serializable
+    private data class LegacyPatchedApp(
+        val packageName: String,
+        val version: String,
+        val isRooted: Boolean,
+        val appliedPatches: List<String>,
+    )
+
     @Serializable
     private data class LegacySettings(
         val keystorePassword: String,
@@ -168,7 +203,6 @@ class MainViewModel(
         val experimentalPatchesEnabled: Boolean? = null,
         val patchesAutoUpdate: Boolean? = null,
         val patchesChangeEnabled: Boolean? = null,
-        val keystore: String? = null,
-        val patches: SerializedSelection? = null,
+        val patchedApps: String? = null,
     )
 }

app/src/main/java/app/revanced/manager/ui/viewmodel/PatchesSelectorViewModel.kt

@@ -129,7 +129,7 @@ class PatchesSelectorViewModel(input: SelectedApplicationInfo.PatchesSelector.Vi
                 isSelected(
                     bundle.uid,
                     patch
-                ) && patch.options?.any { it.required && it.default == null && it.key !in opts } ?: false
+                ) && patch.options?.any { it.required && it.default == null && it.name !in opts } ?: false
             }.toList()
         }.filter { (_, patches) -> patches.isNotEmpty() }
     }
@@ -180,13 +180,13 @@ class PatchesSelectorViewModel(input: SelectedApplicationInfo.PatchesSelector.Vi
 
     fun getOptions(bundle: Int, patch: PatchInfo) = patchOptions[bundle]?.get(patch.name)
 
-    fun setOption(bundle: Int, patch: PatchInfo, key: String, value: Any?) {
+    fun setOption(bundle: Int, patch: PatchInfo, name: String, value: Any?) {
         // All patches
         val patchesToOpts = patchOptions.getOrElse(bundle, ::persistentMapOf)
         // The key-value options of an individual patch
         val patchToOpts = patchesToOpts
             .getOrElse(patch.name, ::persistentMapOf)
-            .put(key, value)
+            .put(name, value)
 
         patchOptions[bundle] = patchesToOpts.put(patch.name, patchToOpts)
     }

app/src/main/java/app/revanced/manager/ui/viewmodel/SelectedAppInfoViewModel.kt

@@ -325,7 +325,7 @@ class SelectedAppInfoViewModel(
                         bundleOptions.forEach patch@{ (patchName, values) ->
                             // Get all valid option keys for the patch.
                             val validOptionKeys =
-                                patches[patchName]?.options?.map { it.key }?.toSet() ?: return@patch
+                                patches[patchName]?.options?.map { it.name }?.toSet() ?: return@patch
 
                             this@bundleOptions[patchName] = values.filterKeys { key ->
                                 key in validOptionKeys

gradle/libs.versions.toml

@@ -17,8 +17,8 @@ serialization = "1.9.0"
 collection = "0.4.0"
 datetime = "0.7.1"
 room-version = "2.8.4"
-revanced-patcher = "21.0.0"
-revanced-library = "3.0.2"
+revanced-patcher = "22.0.0"
+revanced-library = "4.0.0"
 koin = "4.1.1"
 ktor = "3.3.3"
 markdown-renderer = "0.39.0"
@@ -81,8 +81,8 @@ room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room-ver
 room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room-version" }
 
 # Patcher
-revanced-patcher = { group = "app.revanced", name = "revanced-patcher", version.ref = "revanced-patcher" }
-revanced-library = { group = "app.revanced", name = "revanced-library", version.ref = "revanced-library" }
+revanced-patcher = { group = "app.revanced", name = "patcher-android", version.ref = "revanced-patcher" }
+revanced-library = { group = "app.revanced", name = "library-android", version.ref = "revanced-library" }
 
 # Koin
 koin-android = { group = "io.insert-koin", name = "koin-android", version.ref = "koin" }

settings.gradle.kts

@@ -1,5 +1,6 @@
 pluginManagement {
     repositories {
+        mavenLocal()
         mavenCentral()
         google()
         gradlePluginPortal()
@@ -8,6 +9,7 @@ pluginManagement {
 dependencyResolutionManagement {
     repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
     repositories {
+        mavenLocal()
         mavenCentral()
         google()
         maven("https://jitpack.io")