chore(release): 14.2.2 [skip ci]

## [14.2.2](https://github.com/ReVanced/revanced-patcher/compare/v14.2.1...v14.2.2) (2023-08-30)

### Bug Fixes

* allow setting `DexClassLoader.optimizedDirectory` ([11a3378](11a3378659))

.github/workflows/release.yml

@@ -36,7 +36,7 @@ jobs:
       - name: Build with Gradle
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: ./gradlew clean --no-daemon
+        run: ./gradlew build clean --no-daemon
       - name: Setup semantic-release
         run: npm install
       - name: Release

CHANGELOG.md

@@ -1,3 +1,134 @@
+## [14.2.2](https://github.com/ReVanced/revanced-patcher/compare/v14.2.1...v14.2.2) (2023-08-30)
+
+
+### Bug Fixes
+
+* allow setting `DexClassLoader.optimizedDirectory` ([11a3378](https://github.com/ReVanced/revanced-patcher/commit/11a337865947a6ac74a63ebb3f3f9bc2610f7771))
+
+## [14.2.2-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.2.1...v14.2.2-dev.1) (2023-08-29)
+
+
+### Bug Fixes
+
+* allow setting `DexClassLoader.optimizedDirectory` ([11a3378](https://github.com/ReVanced/revanced-patcher/commit/11a337865947a6ac74a63ebb3f3f9bc2610f7771))
+
+## [14.2.1](https://github.com/ReVanced/revanced-patcher/compare/v14.2.0...v14.2.1) (2023-08-27)
+
+
+### Bug Fixes
+
+* do not flag resource table as sparse when main package is not loaded ([b832812](https://github.com/ReVanced/revanced-patcher/commit/b832812767a06ec6ec232291e6d14c8c2f14118c))
+
+## [14.2.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.2.0...v14.2.1-dev.1) (2023-08-27)
+
+
+### Bug Fixes
+
+* do not flag resource table as sparse when main package is not loaded ([b832812](https://github.com/ReVanced/revanced-patcher/commit/b832812767a06ec6ec232291e6d14c8c2f14118c))
+
+# [14.2.0](https://github.com/ReVanced/revanced-patcher/compare/v14.1.0...v14.2.0) (2023-08-27)
+
+
+### Features
+
+* load patches in lexicographical order ([e8f2087](https://github.com/ReVanced/revanced-patcher/commit/e8f2087a6ffa6077fb3a6a69e29f3aec72e2fc1b))
+* log when merging integrations ([983563e](https://github.com/ReVanced/revanced-patcher/commit/983563efb6d7c8d289464b8bf71a016b8a735630))
+
+
+### Performance Improvements
+
+* compare types of classes ([55d6945](https://github.com/ReVanced/revanced-patcher/commit/55d694579ac2718b9e2c61ca5f38419c3775ef87))
+
+# [14.2.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v14.2.0-dev.2...v14.2.0-dev.3) (2023-08-26)
+
+
+### Performance Improvements
+
+* compare types of classes ([55d6945](https://github.com/ReVanced/revanced-patcher/commit/55d694579ac2718b9e2c61ca5f38419c3775ef87))
+
+# [14.2.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v14.2.0-dev.1...v14.2.0-dev.2) (2023-08-26)
+
+
+### Features
+
+* log when merging integrations ([983563e](https://github.com/ReVanced/revanced-patcher/commit/983563efb6d7c8d289464b8bf71a016b8a735630))
+
+# [14.2.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.1.0...v14.2.0-dev.1) (2023-08-25)
+
+
+### Features
+
+* load patches in lexicographical order ([e8f2087](https://github.com/ReVanced/revanced-patcher/commit/e8f2087a6ffa6077fb3a6a69e29f3aec72e2fc1b))
+
+# [14.1.0](https://github.com/ReVanced/revanced-patcher/compare/v14.0.0...v14.1.0) (2023-08-24)
+
+
+### Bug Fixes
+
+* move version properties file to correct package ([e985676](https://github.com/ReVanced/revanced-patcher/commit/e985676c2d8e5d6cb907d371de30428caaa6da43))
+
+
+### Features
+
+* properly make use of logging facade ([ba56a6a](https://github.com/ReVanced/revanced-patcher/commit/ba56a6a2eef503c0d6cdd846ddce2e1474d8ed1a))
+
+# [14.1.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.0.1-dev.1...v14.1.0-dev.1) (2023-08-24)
+
+
+### Features
+
+* properly make use of logging facade ([ba56a6a](https://github.com/ReVanced/revanced-patcher/commit/ba56a6a2eef503c0d6cdd846ddce2e1474d8ed1a))
+
+## [14.0.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v14.0.0...v14.0.1-dev.1) (2023-08-23)
+
+
+### Bug Fixes
+
+* move version properties file to correct package ([e985676](https://github.com/ReVanced/revanced-patcher/commit/e985676c2d8e5d6cb907d371de30428caaa6da43))
+
+# [14.0.0](https://github.com/ReVanced/revanced-patcher/compare/v13.0.0...v14.0.0) (2023-08-22)
+
+
+### Bug Fixes
+
+* log decoding resources after logging deleting resource cache directory ([db62a16](https://github.com/ReVanced/revanced-patcher/commit/db62a1607b4a9d6256b5f5153decb088d9680553))
+* only emit closed patches that did not throw an exception with the `@Patch` annotation ([5938f6b](https://github.com/ReVanced/revanced-patcher/commit/5938f6b7ea25103a0a1b56ceebe49139bc80c6f5))
+* supply the parent classloader to `DexClassLoader` ([0f15077](https://github.com/ReVanced/revanced-patcher/commit/0f15077225600b65200022c1a318e504deb472b9))
+
+
+### Code Refactoring
+
+* improve structure and public API ([6b8977f](https://github.com/ReVanced/revanced-patcher/commit/6b8977f17854ef0344d868e6391cb18134eceadc))
+
+
+### Features
+
+* do not log instantiation of ReVanced Patcher ([273dd8d](https://github.com/ReVanced/revanced-patcher/commit/273dd8d388f8e9b7436c6d6145a94c12c1fabe55))
+
+
+### BREAKING CHANGES
+
+* Various public APIs have been changed. The `Version` annotation has been removed. Patches do not return anything anymore and instead throw `PatchException`. Multiple patch bundles can now be loaded in a single ClassLoader to bypass class loader isolation.
+
+# [14.0.0-dev.4](https://github.com/ReVanced/revanced-patcher/compare/v14.0.0-dev.3...v14.0.0-dev.4) (2023-08-22)
+
+
+### Bug Fixes
+
+* only emit closed patches that did not throw an exception with the `@Patch` annotation ([5938f6b](https://github.com/ReVanced/revanced-patcher/commit/5938f6b7ea25103a0a1b56ceebe49139bc80c6f5))
+
+# [14.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v14.0.0-dev.2...v14.0.0-dev.3) (2023-08-20)
+
+
+### Bug Fixes
+
+* supply the parent classloader to `DexClassLoader` ([0f15077](https://github.com/ReVanced/revanced-patcher/commit/0f15077225600b65200022c1a318e504deb472b9))
+
+
+### Features
+
+* do not log instantiation of ReVanced Patcher ([273dd8d](https://github.com/ReVanced/revanced-patcher/commit/273dd8d388f8e9b7436c6d6145a94c12c1fabe55))
+
 # [14.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v14.0.0-dev.1...v14.0.0-dev.2) (2023-08-19)
 
 # [14.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v13.0.0...v14.0.0-dev.1) (2023-08-18)

build.gradle.kts

@@ -1,39 +1,22 @@
 plugins {
     kotlin("jvm") version "1.8.20"
     `maven-publish`
+    alias(libs.plugins.binary.compatibility.validator)
 }
 
 group = "app.revanced"
 
-val githubUsername: String = project.findProperty("gpr.user") as? String ?: System.getenv("GITHUB_ACTOR")
-val githubPassword: String = project.findProperty("gpr.key") as? String ?: System.getenv("GITHUB_TOKEN")
-
-repositories {
-    mavenCentral()
-    google()
-    mavenLocal()
-    listOf("multidexlib2", "apktool").forEach { repo ->
-        maven {
-            url = uri("https://maven.pkg.github.com/revanced/$repo")
-            credentials {
-                username = githubUsername
-                password = githubPassword
-            }
-        }
-    }
-}
-
 dependencies {
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1")
-    implementation("xpp3:xpp3:1.1.4c")
-    implementation("com.android.tools.smali:smali:3.0.3")
-    implementation("app.revanced:multidexlib2:3.0.3.r2")
-    implementation("app.revanced:apktool-lib:2.8.2-4")
-    implementation("org.jetbrains.kotlin:kotlin-reflect:1.8.22")
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.xpp3)
+    implementation(libs.smali)
+    implementation(libs.multidexlib2)
+    implementation(libs.apktool.lib)
+    implementation(libs.kotlin.reflect)
 
-    compileOnly("com.google.android:android:4.1.1.4")
+    compileOnly(libs.android)
 
-    testImplementation("org.jetbrains.kotlin:kotlin-test:1.8.20-RC")
+    testImplementation(libs.kotlin.test)
 }
 
 tasks {
@@ -43,35 +26,32 @@ tasks {
             events("PASSED", "SKIPPED", "FAILED")
         }
     }
+
     processResources {
         expand("projectVersion" to project.version)
     }
 }
 
+kotlin { jvmToolchain(11) }
+
 java {
     withSourcesJar()
 }
 
-kotlin {
-    jvmToolchain(11)
-}
-
 publishing {
     repositories {
-        if (System.getenv("GITHUB_ACTOR") != null)
-            maven {
-                name = "GitHubPackages"
-                url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
-                credentials {
-                    username = System.getenv("GITHUB_ACTOR")
-                    password = System.getenv("GITHUB_TOKEN")
-                }
+        mavenLocal()
+        maven {
+            name = "GitHubPackages"
+            url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
+            credentials {
+                username = System.getenv("GITHUB_ACTOR")
+                password = System.getenv("GITHUB_TOKEN")
             }
-        else
-            mavenLocal()
+        }
     }
     publications {
-        register<MavenPublication>("gpr") {
+        create<MavenPublication>("gpr") {
             from(components["java"])
         }
     }

gradle.properties

@@ -1,4 +1,4 @@
 org.gradle.parallel = true
 org.gradle.caching = true
 kotlin.code.style = official
-version = 14.0.0-dev.2
+version = 14.2.2

gradle/libs.versions.toml

@@ -0,0 +1,23 @@
+[versions]
+android = "4.1.1.4"
+kotlin-reflect = "1.9.0"
+apktool-lib = "2.8.2-6"
+kotlin-test = "1.8.20-RC"
+kotlinx-coroutines-core = "1.7.1"
+multidexlib2 = "3.0.3.r2"
+smali = "3.0.3"
+xpp3 = "1.1.4c"
+binary-compatibility-validator = "0.13.2"
+
+[libraries]
+android = { module = "com.google.android:android", version.ref = "android" }
+kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin-reflect" }
+apktool-lib = { module = "app.revanced:apktool-lib", version.ref = "apktool-lib" }
+kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin-test" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines-core" }
+multidexlib2 = { module = "app.revanced:multidexlib2", version.ref = "multidexlib2" }
+smali = { module = "com.android.tools.smali:smali", version.ref = "smali" }
+xpp3 = { module = "xpp3:xpp3", version.ref = "xpp3" }
+
+[plugins]
+binary-compatibility-validator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binary-compatibility-validator" }

settings.gradle.kts

@@ -1 +1,22 @@
+val githubUsername: String = providers.gradleProperty("gpr.user").orNull ?: System.getenv("GITHUB_ACTOR")
+val githubPassword: String = providers.gradleProperty("gpr.key").orNull ?: System.getenv("GITHUB_TOKEN")
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        mavenCentral()
+        google()
+        mavenLocal()
+        listOf("multidexlib2", "apktool").forEach { repo ->
+            maven {
+                url = uri("https://maven.pkg.github.com/revanced/$repo")
+                credentials {
+                    username = githubUsername
+                    password = githubPassword
+                }
+            }
+        }
+    }
+}
+
 rootProject.name = "revanced-patcher"

src/main/kotlin/app/revanced/patcher/PatchBundleLoader.kt

@@ -3,9 +3,10 @@
 package app.revanced.patcher
 
 import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
+import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.patch.PatchClass
-import dalvik.system.PathClassLoader
+import dalvik.system.DexClassLoader
 import lanchon.multidexlib2.BasicDexFileNamer
 import lanchon.multidexlib2.MultiDexIO
 import java.io.File
@@ -15,6 +16,7 @@ import java.util.jar.JarFile
 /**
  * A patch bundle.
  *
+ *
  * @param fromClasses The classes to get [Patch]es from.
  */
 sealed class PatchBundleLoader private constructor(
@@ -28,6 +30,8 @@ sealed class PatchBundleLoader private constructor(
         }.map {
             @Suppress("UNCHECKED_CAST")
             it as PatchClass
+        }.sortedBy {
+            it.patchName
         }.let { addAll(it) }
     }
 
@@ -36,43 +40,43 @@ sealed class PatchBundleLoader private constructor(
      *
      * @param patchBundles The path to patch bundles of JAR format.
      */
-    class Jar(private vararg val patchBundles: File) : PatchBundleLoader(
-        with(URLClassLoader(patchBundles.map { it.toURI().toURL() }.toTypedArray())) {
+    class Jar(vararg patchBundles: File) : PatchBundleLoader(
+        with(
+            URLClassLoader(patchBundles.map { it.toURI().toURL() }.toTypedArray())
+        ) {
             patchBundles.flatMap { patchBundle ->
                 // Get the names of all classes in the DEX file.
 
                 JarFile(patchBundle).entries().asSequence()
                     .filter { it.name.endsWith(".class") }
-                    .map {
-                        loadClass(it.name.replace('/', '.').replace(".class", ""))
-                    }
+                    .map { it.name.replace('/', '.').replace(".class", "") }
+                    .map { loadClass(it) }
             }
-        }
-    )
+        })
 
     /**
      * A [PatchBundleLoader] for [Dex] files.
      *
-     * @param patchBundlesPath The path to or a path to a directory containing patch bundles of DEX format.
+     * @param patchBundles The path to patch bundles of DEX format.
+     * @param optimizedDexDirectory The directory to store optimized DEX files in.
+     * This parameter is deprecated and has no effect since API level 26.
      */
-    class Dex(private val patchBundlesPath: File) : PatchBundleLoader(
-        with(PathClassLoader(patchBundlesPath.absolutePath, null)) {
-            fun readDexFile(file: File) = MultiDexIO.readDexFile(
-                true,
-                file,
-                BasicDexFileNamer(),
-                null,
-                null
+    class Dex(vararg patchBundles: File, optimizedDexDirectory: File? = null) : PatchBundleLoader(
+        with(
+            DexClassLoader(
+            patchBundles.joinToString(File.pathSeparator) { it.absolutePath }, optimizedDexDirectory?.absolutePath,
+            null,
+            PatchBundleLoader::class.java.classLoader
             )
-
-            // Get the names of all classes in the DEX file.
-
-            val dexFiles = if (patchBundlesPath.isFile) listOf(readDexFile(patchBundlesPath))
-            else patchBundlesPath.listFiles { it -> it.isFile }?.map { readDexFile(it) } ?: emptyList()
-
-            dexFiles.flatMap { it.classes }.map { classDef ->
-                classDef.type.substring(1, classDef.length - 1).replace('/', '.')
-            }.map { loadClass(it) }
-        }
-    )
+        ) {
+        patchBundles
+            .flatMap {
+                MultiDexIO.readDexFile(true, it, BasicDexFileNamer(), null, null).classes
+            }
+            .map { classDef -> classDef.type.substring(1, classDef.length - 1) }
+            .map { loadClass(it) }
+        }) {
+        @Deprecated("This constructor is deprecated. Use the constructor with the second parameter instead.")
+        constructor(vararg patchBundles: File) : this(*patchBundles, optimizedDexDirectory = null)
+    }
 }

src/main/kotlin/app/revanced/patcher/Patcher.kt

@@ -2,6 +2,7 @@ package app.revanced.patcher
 
 import app.revanced.patcher.data.Context
 import app.revanced.patcher.data.ResourceContext
+import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
 import app.revanced.patcher.extensions.PatchExtensions.dependencies
 import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.extensions.PatchExtensions.requiresIntegrations
@@ -14,6 +15,7 @@ import java.io.File
 import java.util.function.Supplier
 import java.util.logging.Level
 import java.util.logging.LogManager
+import java.util.logging.Logger
 
 /**
  * ReVanced Patcher.
@@ -23,6 +25,8 @@ import java.util.logging.LogManager
 class Patcher(
     private val options: PatcherOptions
 ) : PatchExecutorFunction, PatchesConsumer, IntegrationsConsumer, Supplier<PatcherResult>, Closeable {
+    private val logger = Logger.getLogger(Patcher::class.java.name)
+
     /**
      * The context of ReVanced [Patcher].
      * This holds the current state of the patcher.
@@ -30,8 +34,6 @@ class Patcher(
     val context = PatcherContext(options)
 
     init {
-        options.logger.info("Instantiating ReVanced Patcher")
-
         LogManager.getLogManager().let { manager ->
             // Disable root logger.
             manager.getLogger("").level = Level.OFF
@@ -160,7 +162,7 @@ class Patcher(
         if (options.resourceDecodingMode == ResourceContext.ResourceDecodingMode.FULL)
             context.resourceContext.decodeResources(ResourceContext.ResourceDecodingMode.FULL)
 
-        options.logger.info("Executing patches")
+        logger.info("Executing patches")
 
         val executedPatches = LinkedHashMap<String, ExecutedPatch>() // Key is name.
 
@@ -204,7 +206,15 @@ class Patcher(
                     )
 
                     if (returnOnError) return@flow
-                } ?: emit(result)
+                } ?: run {
+                    executedPatch
+                        .patchInstance::class
+                        .java
+                        .findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class)
+                        ?: return@run
+
+                    emit(result)
+                }
             }
     }
 

src/main/kotlin/app/revanced/patcher/PatcherOptions.kt

@@ -1,10 +1,10 @@
 package app.revanced.patcher
 
 import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.logging.Logger
 import app.revanced.patcher.logging.impl.NopLogger
 import brut.androlib.Config
 import java.io.File
+import java.util.logging.Logger
 
 /**
  * Options for ReVanced [Patcher].
@@ -12,15 +12,19 @@ import java.io.File
  * @param resourceCachePath The path to the directory to use for caching resources.
  * @param aaptBinaryPath The path to a custom aapt binary.
  * @param frameworkFileDirectory The path to the directory to cache the framework file in.
- * @param logger A [Logger].
+ * @param unusedLogger The logger to use for logging.
  */
-data class PatcherOptions(
+data class PatcherOptions
+@Deprecated("Use the constructor without the logger parameter instead")
+constructor(
     internal val inputFile: File,
     internal val resourceCachePath: File = File("revanced-resource-cache"),
     internal val aaptBinaryPath: String? = null,
     internal val frameworkFileDirectory: String? = null,
-    internal val logger: Logger = NopLogger
+    internal val unusedLogger: app.revanced.patcher.logging.Logger = NopLogger
 ) {
+    private val logger = Logger.getLogger(PatcherOptions::class.java.name)
+
     /**
      * The mode to use for resource decoding.
      * @see ResourceContext.ResourceDecodingMode
@@ -36,12 +40,32 @@ data class PatcherOptions(
         frameworkDirectory = frameworkFileDirectory
     }
 
+    /**
+     * Options for ReVanced [Patcher].
+     * @param inputFile The input file to patch.
+     * @param resourceCachePath The path to the directory to use for caching resources.
+     * @param aaptBinaryPath The path to a custom aapt binary.
+     * @param frameworkFileDirectory The path to the directory to cache the framework file in.
+     */
+    constructor(
+        inputFile: File,
+        resourceCachePath: File = File("revanced-resource-cache"),
+        aaptBinaryPath: String? = null,
+        frameworkFileDirectory: String? = null,
+    ) : this(
+        inputFile,
+        resourceCachePath,
+        aaptBinaryPath,
+        frameworkFileDirectory,
+        NopLogger
+    )
+
     fun recreateResourceCacheDirectory() = resourceCachePath.also {
         if (it.exists()) {
             logger.info("Deleting existing resource cache directory")
 
             if (!it.deleteRecursively())
-                logger.error("Failed to delete existing resource cache directory")
+                logger.severe("Failed to delete existing resource cache directory")
         }
 
         it.mkdirs()

src/main/kotlin/app/revanced/patcher/data/BytecodeContext.kt

@@ -1,8 +1,10 @@
 package app.revanced.patcher.data
 
+import app.revanced.patcher.PatcherContext
 import app.revanced.patcher.PatcherOptions
 import app.revanced.patcher.PatcherResult
-import app.revanced.patcher.logging.Logger
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.annotations.RequiresIntegrations
 import app.revanced.patcher.util.ClassMerger.merge
 import app.revanced.patcher.util.ProxyClassList
 import app.revanced.patcher.util.method.MethodWalker
@@ -17,6 +19,7 @@ import lanchon.multidexlib2.DexIO
 import lanchon.multidexlib2.MultiDexIO
 import java.io.File
 import java.io.Flushable
+import java.util.logging.Logger
 
 /**
  * A context for bytecode.
@@ -26,6 +29,8 @@ import java.io.Flushable
  */
 class BytecodeContext internal constructor(private val options: PatcherOptions) :
     Context<List<PatcherResult.PatchedDexFile>> {
+    private val logger = Logger.getLogger(BytecodeContext::class.java.name)
+
     /**
      * [Opcodes] of the supplied [PatcherOptions.inputFile].
      */
@@ -45,7 +50,7 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
     /**
      * The [Integrations] of this [PatcherContext].
      */
-    internal val integrations = Integrations(options.logger)
+    internal val integrations = Integrations()
 
     /**
      * Find a class by a given class name.
@@ -88,10 +93,8 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
 
     /**
      * The integrations of a [PatcherContext].
-     *
-     * @param logger The logger to use.
      */
-    internal inner class Integrations(private val logger: Logger) : MutableList<File> by mutableListOf(), Flushable {
+    internal inner class Integrations : MutableList<File> by mutableListOf(), Flushable {
         /**
          * Whether to merge integrations.
          * True when any supplied [Patch] is annotated with [RequiresIntegrations].
@@ -104,6 +107,9 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
         override fun flush() {
             if (!merge) return
 
+            logger.info("Merging integrations")
+
+            // TODO: Multi-thread this.
             this@Integrations.forEach { integrations ->
                 MultiDexIO.readDexFile(
                     true,
@@ -111,15 +117,15 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
                     null,
                     null
                 ).classes.forEach classDef@{ classDef ->
-                    val existingClass = classes.find { it == classDef } ?: run {
-                        logger.trace("Merging $classDef")
+                    val existingClass = classes.find { it.type == classDef.type } ?: run {
+                        logger.fine("Merging $classDef")
                         classes.add(classDef)
                         return@classDef
                     }
 
-                    logger.trace("$classDef exists. Adding missing methods and fields.")
+                    logger.fine("$classDef exists. Adding missing methods and fields.")
 
-                    existingClass.merge(classDef, this@BytecodeContext, logger).let { mergedClass ->
+                    existingClass.merge(classDef, this@BytecodeContext).let { mergedClass ->
                         // If the class was merged, replace the original class with the merged class.
                         if (mergedClass === existingClass) return@let
                         classes.apply { remove(existingClass); add(mergedClass) }
@@ -137,7 +143,7 @@ class BytecodeContext internal constructor(private val options: PatcherOptions)
      * @return The compiled bytecode.
      */
     override fun get(): List<PatcherResult.PatchedDexFile> {
-        options.logger.info("Compiling modified dex files")
+        logger.info("Compiling modified dex files")
 
         return mutableMapOf<String, MemoryDataStore>().apply {
             MultiDexIO.writeDexFile(

src/main/kotlin/app/revanced/patcher/data/ResourceContext.kt

@@ -16,6 +16,7 @@ import java.io.File
 import java.io.InputStream
 import java.io.OutputStream
 import java.nio.file.Files
+import java.util.logging.Logger
 
 /**
  * A context for resources.
@@ -27,6 +28,8 @@ class ResourceContext internal constructor(
     private val context: PatcherContext,
     private val options: PatcherOptions
 ) : Context<File?>, Iterable<File> {
+    private val logger = Logger.getLogger(ResourceContext::class.java.name)
+
     val xmlEditor = XmlFileHolder()
 
     /**
@@ -42,7 +45,7 @@ class ResourceContext internal constructor(
             ResourceDecodingMode.FULL -> {
                 val outDir = options.recreateResourceCacheDirectory()
 
-                options.logger.info("Decoding resources")
+                logger.info("Decoding resources")
 
                 resourcesDecoder.decodeResources(outDir)
                 resourcesDecoder.decodeManifest(outDir)
@@ -57,7 +60,7 @@ class ResourceContext internal constructor(
             }
 
             ResourceDecodingMode.MANIFEST_ONLY -> {
-                options.logger.info("Decoding app manifest")
+                logger.info("Decoding app manifest")
 
                 // Decode manually instead of using resourceDecoder.decodeManifest
                 // because it does not support decoding to an OutputStream.
@@ -80,6 +83,16 @@ class ResourceContext internal constructor(
                     versionInfo.let {
                         metadata.packageVersion = it.versionName ?: it.versionCode
                     }
+
+                    /*
+                     The ResTable if flagged as sparse if the main package is not loaded, which is the case here,
+                     because ResourcesDecoder.decodeResources loads the main package
+                     and not XmlPullStreamDecoder.decodeManifest.
+                     See ARSCDecoder.readTableType for more info.
+
+                     Set this to false again to prevent the ResTable from being flagged as sparse falsely.
+                     */
+                    metadata.apkInfo.sparseResources = false
                 }
             }
         }
@@ -100,7 +113,7 @@ class ResourceContext internal constructor(
         var resourceFile: File? = null
 
         if (options.resourceDecodingMode == ResourceDecodingMode.FULL) {
-            options.logger.info("Compiling modified resources")
+            logger.info("Compiling modified resources")
 
             val cacheDirectory = ExtFile(options.resourceCachePath)
             val aaptFile = cacheDirectory.resolve("aapt_temp_file").also {

src/main/kotlin/app/revanced/patcher/logging/Logger.kt

@@ -1,5 +1,6 @@
 package app.revanced.patcher.logging
 
+@Deprecated("This will be removed in a future release")
 interface Logger {
     fun error(msg: String) {}
     fun warn(msg: String) {}

src/main/kotlin/app/revanced/patcher/logging/impl/NopLogger.kt

@@ -2,4 +2,5 @@ package app.revanced.patcher.logging.impl
 
 import app.revanced.patcher.logging.Logger
 
+@Deprecated("This will be removed in a future release")
 object NopLogger : Logger

src/main/kotlin/app/revanced/patcher/util/ClassMerger.kt

@@ -2,7 +2,6 @@ package app.revanced.patcher.util
 
 import app.revanced.patcher.data.BytecodeContext
 import app.revanced.patcher.extensions.or
-import app.revanced.patcher.logging.Logger
 import app.revanced.patcher.util.ClassMerger.Utils.asMutableClass
 import app.revanced.patcher.util.ClassMerger.Utils.filterAny
 import app.revanced.patcher.util.ClassMerger.Utils.filterNotAny
@@ -18,6 +17,7 @@ import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMu
 import com.android.tools.smali.dexlib2.AccessFlags
 import com.android.tools.smali.dexlib2.iface.ClassDef
 import com.android.tools.smali.dexlib2.util.MethodUtil
+import java.util.logging.Logger
 import kotlin.reflect.KFunction2
 
 /**
@@ -25,28 +25,28 @@ import kotlin.reflect.KFunction2
  * Note: This will not consider method implementations or if the class is missing a superclass or interfaces.
  */
 internal object ClassMerger {
+    private val logger = Logger.getLogger(ClassMerger::class.java.name)
+
     /**
      * Merge a class with [otherClass].
      *
      * @param otherClass The class to merge with
      * @param context The context to traverse the class hierarchy in.
-     * @param logger A logger.
      * @return The merged class or the original class if no merge was needed.
      */
-    fun ClassDef.merge(otherClass: ClassDef, context: BytecodeContext, logger: Logger? = null) = this
-        //.fixFieldAccess(otherClass, logger)
-        //.fixMethodAccess(otherClass, logger)
-        .addMissingFields(otherClass, logger)
-        .addMissingMethods(otherClass, logger)
-        .publicize(otherClass, context, logger)
+    fun ClassDef.merge(otherClass: ClassDef, context: BytecodeContext) = this
+        //.fixFieldAccess(otherClass)
+        //.fixMethodAccess(otherClass)
+        .addMissingFields(otherClass)
+        .addMissingMethods(otherClass)
+        .publicize(otherClass, context)
 
     /**
      * Add methods which are missing but existing in [fromClass].
      *
      * @param fromClass The class to add missing methods from.
-     * @param logger A logger.
      */
-    private fun ClassDef.addMissingMethods(fromClass: ClassDef, logger: Logger? = null): ClassDef {
+    private fun ClassDef.addMissingMethods(fromClass: ClassDef): ClassDef {
         val missingMethods = fromClass.methods.let { fromMethods ->
             methods.filterNot { method ->
                 fromMethods.any { fromMethod ->
@@ -57,7 +57,7 @@ internal object ClassMerger {
 
         if (missingMethods.isEmpty()) return this
 
-        logger?.trace("Found ${missingMethods.size} missing methods")
+        logger.fine("Found ${missingMethods.size} missing methods")
 
         return asMutableClass().apply {
             methods.addAll(missingMethods.map { it.toMutable() })
@@ -68,16 +68,15 @@ internal object ClassMerger {
      * Add fields which are missing but existing in [fromClass].
      *
      * @param fromClass The class to add missing fields from.
-     * @param logger A logger.
      */
-    private fun ClassDef.addMissingFields(fromClass: ClassDef, logger: Logger? = null): ClassDef {
+    private fun ClassDef.addMissingFields(fromClass: ClassDef): ClassDef {
         val missingFields = fields.filterNotAny(fromClass.fields) { field, fromField ->
             fromField.name == field.name
         }
 
         if (missingFields.isEmpty()) return this
 
-        logger?.trace("Found ${missingFields.size} missing fields")
+        logger.fine("Found ${missingFields.size} missing fields")
 
         return asMutableClass().apply {
             fields.addAll(missingFields.map { it.toMutable() })
@@ -88,15 +87,14 @@ internal object ClassMerger {
      * Make a class and its super class public recursively.
      * @param reference The class to check the [AccessFlags] of.
      * @param context The context to traverse the class hierarchy in.
-     * @param logger A logger.
      */
-    private fun ClassDef.publicize(reference: ClassDef, context: BytecodeContext, logger: Logger? = null) =
+    private fun ClassDef.publicize(reference: ClassDef, context: BytecodeContext) =
         if (reference.accessFlags.isPublic() && !accessFlags.isPublic())
             this.asMutableClass().apply {
                 context.traverseClassHierarchy(this) {
                     if (accessFlags.isPublic()) return@traverseClassHierarchy
 
-                    logger?.trace("Publicizing ${this.type}")
+                    logger.fine("Publicizing ${this.type}")
 
                     accessFlags = accessFlags.toPublic()
                 }
@@ -107,9 +105,8 @@ internal object ClassMerger {
      * Publicize fields if they are public in [reference].
      *
      * @param reference The class to check the [AccessFlags] of the fields in.
-     * @param logger A logger.
      */
-    private fun ClassDef.fixFieldAccess(reference: ClassDef, logger: Logger? = null): ClassDef {
+    private fun ClassDef.fixFieldAccess(reference: ClassDef): ClassDef {
         val brokenFields = fields.filterAny(reference.fields) { field, referenceField ->
             if (field.name != referenceField.name) return@filterAny false
 
@@ -118,7 +115,7 @@ internal object ClassMerger {
 
         if (brokenFields.isEmpty()) return this
 
-        logger?.trace("Found ${brokenFields.size} broken fields")
+        logger.fine("Found ${brokenFields.size} broken fields")
 
         /**
          * Make a field public.
@@ -136,9 +133,8 @@ internal object ClassMerger {
      * Publicize methods if they are public in [reference].
      *
      * @param reference The class to check the [AccessFlags] of the methods in.
-     * @param logger A logger.
      */
-    private fun ClassDef.fixMethodAccess(reference: ClassDef, logger: Logger? = null): ClassDef {
+    private fun ClassDef.fixMethodAccess(reference: ClassDef): ClassDef {
         val brokenMethods = methods.filterAny(reference.methods) { method, referenceMethod ->
             if (!MethodUtil.methodSignaturesMatch(method, referenceMethod)) return@filterAny false
 
@@ -147,7 +143,7 @@ internal object ClassMerger {
 
         if (brokenMethods.isEmpty()) return this
 
-        logger?.trace("Found ${brokenMethods.size} methods")
+        logger.fine("Found ${brokenMethods.size} methods")
 
         /**
          * Make a method public.
@@ -194,7 +190,6 @@ internal object ClassMerger {
         /**
          * Filter [this] on [needles] matching the given [predicate].
          *
-         * @param this The hay to filter for [needles].
          * @param needles The needles to filter [this] with.
          * @param predicate The filter.
          * @return The [this] filtered on [needles] matching the given [predicate].
@@ -206,7 +201,6 @@ internal object ClassMerger {
         /**
          * Filter [this] on [needles] not matching the given [predicate].
          *
-         * @param this The hay to filter for [needles].
          * @param needles The needles to filter [this] with.
          * @param predicate The filter.
          * @return The [this] filtered on [needles] not matching the given [predicate].

src/test/kotlin/app/revanced/patcher/patch/PatchOptionsTest.kt

@@ -3,7 +3,9 @@ package app.revanced.patcher.patch
 import app.revanced.patcher.usage.bytecode.ExampleBytecodePatch
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
+import kotlin.test.assertNotNull
 
 internal class PatchOptionsTest {
     private val options = ExampleBytecodePatch.options
@@ -23,14 +25,14 @@ internal class PatchOptionsTest {
                 is PatchOption.StringListOption -> {
                     option.value = option.options.first()
                     for (choice in option.options) {
-                        println(choice)
+                        assertNotNull(choice)
                     }
                 }
 
                 is PatchOption.IntListOption -> {
                     option.value = option.options.first()
                     for (choice in option.options) {
-                        println(choice)
+                        assertNotNull(choice)
                     }
                 }
             }
@@ -38,9 +40,9 @@ internal class PatchOptionsTest {
         val option = options.get<String>("key1")
         // or: val option: String? by options["key1"]
         // then you won't need `.value` every time
-        println(option.value)
+        assertEquals("Hello World", option.value)
         options["key1"] = "Hello, world!"
-        println(option.value)
+        assertEquals("Hello, world!", option.value)
     }
 
     @Test
@@ -101,7 +103,7 @@ internal class PatchOptionsTest {
     @Test
     fun `should fail because getting a non-initialized option is illegal`() {
         assertThrows<RequirementNotMetException> {
-            println(options["key5"].value)
+            options["key5"].value
         }
     }
 }