chore(release): 14.2.0-dev.2 [skip ci]

# [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](983563efb6))

.gitattributes

@@ -0,0 +1,9 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+

.releaserc

@@ -7,7 +7,13 @@
     }
   ],
   "plugins": [
-    "@semantic-release/commit-analyzer",
+    [
+      "@semantic-release/commit-analyzer", {
+        "releaseRules": [
+          { "type": "build", "scope": "Needs bump", "release": "patch" }
+        ]
+      }
+    ],
     "@semantic-release/release-notes-generator",
     "@semantic-release/changelog",
     "gradle-semantic-release-plugin",

CHANGELOG.md

@@ -1,3 +1,284 @@
+# [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)
+
+
+### Bug Fixes
+
+* log decoding resources after logging deleting resource cache directory ([db62a16](https://github.com/ReVanced/revanced-patcher/commit/db62a1607b4a9d6256b5f5153decb088d9680553))
+
+
+### Code Refactoring
+
+* improve structure and public API ([6b8977f](https://github.com/ReVanced/revanced-patcher/commit/6b8977f17854ef0344d868e6391cb18134eceadc))
+
+
+### 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.
+
+# [13.0.0](https://github.com/ReVanced/revanced-patcher/compare/v12.1.1...v13.0.0) (2023-08-14)
+
+
+### Bug Fixes
+
+* decode in correct order ([8fb2f2d](https://github.com/ReVanced/revanced-patcher/commit/8fb2f2dc1d3b9b1e9fd13b39485985d2886d52ae))
+* disable correct loggers ([c2d89c6](https://github.com/ReVanced/revanced-patcher/commit/c2d89c622e06e58e5042e1a00ef67cee8a246e53))
+* get framework ids to compile resources ([f2cb7ee](https://github.com/ReVanced/revanced-patcher/commit/f2cb7ee7dffa573c31df497cf235a3f5d120f91f))
+* only enable logging for ReVanced ([783ccf8](https://github.com/ReVanced/revanced-patcher/commit/783ccf8529f5d16aa463982da6977328306232bb))
+* set package metadata correctly ([02d6ff1](https://github.com/ReVanced/revanced-patcher/commit/02d6ff15fe87c2352de29749610e9d72db8ba418))
+
+
+* build(Needs bump)!: Bump dependencies ([d5f89a9](https://github.com/ReVanced/revanced-patcher/commit/d5f89a903f019c199bdb27a50287124fc4b4978e))
+
+
+### BREAKING CHANGES
+
+* This bump updates smali, a crucial dependency
+
+# [13.0.0-dev.3](https://github.com/ReVanced/revanced-patcher/compare/v13.0.0-dev.2...v13.0.0-dev.3) (2023-08-14)
+
+
+### Bug Fixes
+
+* decode in correct order ([8fb2f2d](https://github.com/ReVanced/revanced-patcher/commit/8fb2f2dc1d3b9b1e9fd13b39485985d2886d52ae))
+* only enable logging for ReVanced ([783ccf8](https://github.com/ReVanced/revanced-patcher/commit/783ccf8529f5d16aa463982da6977328306232bb))
+
+# [13.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v13.0.0-dev.1...v13.0.0-dev.2) (2023-08-12)
+
+
+### Bug Fixes
+
+* disable correct loggers ([c2d89c6](https://github.com/ReVanced/revanced-patcher/commit/c2d89c622e06e58e5042e1a00ef67cee8a246e53))
+* get framework ids to compile resources ([f2cb7ee](https://github.com/ReVanced/revanced-patcher/commit/f2cb7ee7dffa573c31df497cf235a3f5d120f91f))
+* set package metadata correctly ([02d6ff1](https://github.com/ReVanced/revanced-patcher/commit/02d6ff15fe87c2352de29749610e9d72db8ba418))
+
+# [13.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v12.1.1...v13.0.0-dev.1) (2023-08-11)
+
+
+* build(Needs bump)!: Bump dependencies ([d5f89a9](https://github.com/ReVanced/revanced-patcher/commit/d5f89a903f019c199bdb27a50287124fc4b4978e))
+
+
+### BREAKING CHANGES
+
+* This bump updates smali, a crucial dependency
+
+## [12.1.1](https://github.com/ReVanced/revanced-patcher/compare/v12.1.0...v12.1.1) (2023-08-03)
+
+
+### Bug Fixes
+
+* clear method lookup maps before initializing them ([#210](https://github.com/ReVanced/revanced-patcher/issues/210)) ([746544f](https://github.com/ReVanced/revanced-patcher/commit/746544f9d51d1013bb160075709cd26bffd425b3))
+
+## [12.1.1-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v12.1.1-dev.1...v12.1.1-dev.2) (2023-08-03)
+
+## [12.1.1-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v12.1.0...v12.1.1-dev.1) (2023-08-03)
+
+
+### Bug Fixes
+
+* clear method lookup maps before initializing them ([#210](https://github.com/ReVanced/revanced-patcher/issues/210)) ([746544f](https://github.com/ReVanced/revanced-patcher/commit/746544f9d51d1013bb160075709cd26bffd425b3))
+
+# [12.1.0](https://github.com/ReVanced/revanced-patcher/compare/v12.0.0...v12.1.0) (2023-08-03)
+
+
+### Features
+
+* add `MutableMethod.getInstructions` extension function ([fae4029](https://github.com/ReVanced/revanced-patcher/commit/fae4029cfccfad7aa3dd8f7fbef1c63ee26b85b3))
+
+# [12.1.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v12.1.0-dev.1...v12.1.0-dev.2) (2023-08-03)
+
+# [12.1.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v12.0.0...v12.1.0-dev.1) (2023-08-01)
+
+
+### Features
+
+* add `MutableMethod.getInstructions` extension function ([fae4029](https://github.com/ReVanced/revanced-patcher/commit/fae4029cfccfad7aa3dd8f7fbef1c63ee26b85b3))
+
+# [12.0.0](https://github.com/ReVanced/revanced-patcher/compare/v11.0.4...v12.0.0) (2023-07-30)
+
+
+### Bug Fixes
+
+* correct access flags of `PackageMetadata` ([416d691](https://github.com/ReVanced/revanced-patcher/commit/416d69142f50dab49c9ea3f027e9d53e4777f257))
+* set resource table via resource decoder ([e0f8e1b](https://github.com/ReVanced/revanced-patcher/commit/e0f8e1b71a295948b610029c89a48f52762396b6))
+
+
+### Features
+
+* Deprecate `Version` annotation ([c9bbcf2](https://github.com/ReVanced/revanced-patcher/commit/c9bbcf2bf2b0f50ab9100380a3a66c6346ad42ac))
+* remove `Path` option ([#202](https://github.com/ReVanced/revanced-patcher/issues/202)) ([69e4a49](https://github.com/ReVanced/revanced-patcher/commit/69e4a490659ebc4fb4bf46148634f4b064ef1713))
+
+
+### BREAKING CHANGES
+
+* This removes the previously available `Path` option
+
+# [12.0.0-dev.2](https://github.com/ReVanced/revanced-patcher/compare/v12.0.0-dev.1...v12.0.0-dev.2) (2023-07-28)
+
+
+### Features
+
+* Deprecate `Version` annotation ([400442f](https://github.com/ReVanced/revanced-patcher/commit/400442f70ee56cafd4493b2ce64a294db9836509))
+
+# [12.0.0-dev.1](https://github.com/ReVanced/revanced-patcher/compare/v11.0.4...v12.0.0-dev.1) (2023-07-26)
+
+
+### Bug Fixes
+
+* correct access flags of `PackageMetadata` ([416d691](https://github.com/ReVanced/revanced-patcher/commit/416d69142f50dab49c9ea3f027e9d53e4777f257))
+* set resource table via resource decoder ([e0f8e1b](https://github.com/ReVanced/revanced-patcher/commit/e0f8e1b71a295948b610029c89a48f52762396b6))
+
+
+### Features
+
+* remove `Path` option ([#202](https://github.com/ReVanced/revanced-patcher/issues/202)) ([69e4a49](https://github.com/ReVanced/revanced-patcher/commit/69e4a490659ebc4fb4bf46148634f4b064ef1713))
+
+
+### BREAKING CHANGES
+
+* This removes the previously available `Path` option
+
+## [11.0.4](https://github.com/revanced/revanced-patcher/compare/v11.0.3...v11.0.4) (2023-07-01)
+
+
+### Bug Fixes
+
+* clear method lookup maps ([#198](https://github.com/revanced/revanced-patcher/issues/198)) ([9d81baf](https://github.com/revanced/revanced-patcher/commit/9d81baf4b4ca7514f8a1009e72218638609a7c7f))
+
+## [11.0.4-dev.1](https://github.com/revanced/revanced-patcher/compare/v11.0.3...v11.0.4-dev.1) (2023-07-01)
+
+
+### Bug Fixes
+
+* clear method lookup maps ([#198](https://github.com/revanced/revanced-patcher/issues/198)) ([9d81baf](https://github.com/revanced/revanced-patcher/commit/9d81baf4b4ca7514f8a1009e72218638609a7c7f))
+
+## [11.0.3](https://github.com/revanced/revanced-patcher/compare/v11.0.2...v11.0.3) (2023-06-30)
+
+
+### Bug Fixes
+
+* NPE on method lookup ([#195](https://github.com/revanced/revanced-patcher/issues/195)) ([fcef434](https://github.com/revanced/revanced-patcher/commit/fcef4342e8bde73945e8315aef6337cc8a8d8572))
+
+## [11.0.3-dev.1](https://github.com/revanced/revanced-patcher/compare/v11.0.2...v11.0.3-dev.1) (2023-06-28)
+
+
+### Bug Fixes
+
+* NPE on method lookup ([#195](https://github.com/revanced/revanced-patcher/issues/195)) ([fcef434](https://github.com/revanced/revanced-patcher/commit/fcef4342e8bde73945e8315aef6337cc8a8d8572))
+
+## [11.0.2](https://github.com/revanced/revanced-patcher/compare/v11.0.1...v11.0.2) (2023-06-27)
+
+
+### Bug Fixes
+
+* catch exceptions from closing patches ([d5d6f85](https://github.com/revanced/revanced-patcher/commit/d5d6f85084c03ed9c776632823ca12394a716167))
+* do not load annotations as patches ([519359a](https://github.com/revanced/revanced-patcher/commit/519359a9eb0e9dfa390c5016e9fe4a7490b8ab18))
+* only close succeeded patches ([b8151eb](https://github.com/revanced/revanced-patcher/commit/b8151ebccb5b27dd9e06fa63235cf9baeef1c0ee))
+* use `versionCode` if `versionName` is unavailable ([6e1b647](https://github.com/revanced/revanced-patcher/commit/6e1b6479b677657c226693e9cc6b63f4ef2ee060))
+
+
+### Performance Improvements
+
+* resolve fingerprints using method maps ([#185](https://github.com/revanced/revanced-patcher/issues/185)) ([d718134](https://github.com/revanced/revanced-patcher/commit/d718134ab26423e02708e01eba711737f9260ba0))
+
+## [11.0.2-dev.4](https://github.com/revanced/revanced-patcher/compare/v11.0.2-dev.3...v11.0.2-dev.4) (2023-06-27)
+
+
+### Bug Fixes
+
+* do not load annotations as patches ([519359a](https://github.com/revanced/revanced-patcher/commit/519359a9eb0e9dfa390c5016e9fe4a7490b8ab18))
+
+## [11.0.2-dev.3](https://github.com/revanced/revanced-patcher/compare/v11.0.2-dev.2...v11.0.2-dev.3) (2023-06-27)
+
+
+### Performance Improvements
+
+* resolve fingerprints using method maps ([#185](https://github.com/revanced/revanced-patcher/issues/185)) ([d718134](https://github.com/revanced/revanced-patcher/commit/d718134ab26423e02708e01eba711737f9260ba0))
+
 ## [11.0.2-dev.2](https://github.com/revanced/revanced-patcher/compare/v11.0.2-dev.1...v11.0.2-dev.2) (2023-06-18)
 
 

build.gradle.kts

@@ -1,32 +1,21 @@
 plugins {
-    kotlin("jvm") version "1.8.10"
+    kotlin("jvm") version "1.8.20"
     `maven-publish`
 }
 
 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()
-    maven {
-        url = uri("https://maven.pkg.github.com/revanced/multidexlib2")
-        credentials {
-            username = githubUsername
-            password = githubPassword
-        }
-    }
-}
-
 dependencies {
-    implementation("xpp3:xpp3:1.1.4c")
+    implementation(libs.kotlinx.coroutines.core)
-    implementation("app.revanced:smali:2.5.3-a3836654")
+    implementation(libs.xpp3)
-    implementation("app.revanced:multidexlib2:2.5.3-a3836654")
+    implementation(libs.smali)
-    implementation("app.revanced:apktool-lib:2.7.0")
+    implementation(libs.multidexlib2)
+    implementation(libs.apktool.lib)
+    implementation(libs.kotlin.reflect)
 
-    implementation("org.jetbrains.kotlin:kotlin-reflect:1.8.20-RC")
+    compileOnly(libs.android)
-    testImplementation("org.jetbrains.kotlin:kotlin-test:1.8.20-RC")
+
+    testImplementation(libs.kotlin.test)
 }
 
 tasks {
@@ -36,35 +25,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)
+        mavenLocal()
-            maven {
+        maven {
-                name = "GitHubPackages"
+            name = "GitHubPackages"
-                url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
+            url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
-                credentials {
+            credentials {
-                    username = System.getenv("GITHUB_ACTOR")
+                username = System.getenv("GITHUB_ACTOR")
-                    password = System.getenv("GITHUB_TOKEN")
+                password = System.getenv("GITHUB_TOKEN")
-                }
             }
-        else
+        }
-            mavenLocal()
     }
     publications {
-        register<MavenPublication>("gpr") {
+        create<MavenPublication>("gpr") {
             from(components["java"])
         }
     }

gradle.properties

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

gradle/libs.versions.toml

@@ -0,0 +1,21 @@
+[versions]
+android = "4.1.1.4"
+kotlin-reflect = "1.9.0"
+apktool-lib = "2.8.2-5"
+kotlin-test = "1.8.20-RC"
+kotlinx-coroutines-core = "1.7.1"
+multidexlib2 = "3.0.3.r2"
+shadow = "8.1.1"
+smali = "3.0.3"
+xpp3 = "1.1.4c"
+
+
+[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" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright <EFBFBD> 2015-2021 the original authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -32,10 +32,10 @@
 #       Busybox and similar reduced shells will NOT work, because this script
 #       requires all of these POSIX shell features:
 #         * functions;
-#         * expansions <EFBFBD>$var<EFBFBD>, <EFBFBD>${var}<EFBFBD>, <EFBFBD>${var:-default}<EFBFBD>, <EFBFBD>${var+SET}<EFBFBD>,
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           <EFBFBD>${var#prefix}<EFBFBD>, <EFBFBD>${var%suffix}<EFBFBD>, and <EFBFBD>$( cmd )<EFBFBD>;
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially <EFBFBD>case<EFBFBD>;
+#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including <EFBFBD>command<EFBFBD>, <EFBFBD>set<EFBFBD>, and <EFBFBD>ulimit<EFBFBD>.
+#         * various built-in commands including «command», «set», and «ulimit».
 #
 #   Important for patching:
 #
@@ -55,7 +55,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -80,13 +80,10 @@ do
     esac
 done
 
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+# This is normally unused
-
+# shellcheck disable=SC2034
-APP_NAME="Gradle"
 APP_BASE_NAME=${0##*/}
-
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -133,22 +130,29 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
     case $MAX_FD in  #(
       '' | soft) :;; #(
       *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -193,6 +197,10 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
 # Collect all arguments for the java command;
 #   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
 #     shell script including quotes and variable substitutions, so put them in
@@ -205,6 +213,12 @@ set -- \
         org.gradle.wrapper.GradleWrapperMain \
         "$@"
 
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
 # Use "xargs" to parse quoted args.
 #
 # With -n1 it outputs one arg per line, with the quotes and backslashes removed.

gradlew.bat

@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +25,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -75,13 +76,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+set EXIT_CODE=%ERRORLEVEL%
-exit /b 1
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

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/IntegrationsConsumer.kt

@@ -0,0 +1,8 @@
+package app.revanced.patcher
+
+import java.io.File
+
+@FunctionalInterface
+interface IntegrationsConsumer {
+    fun acceptIntegrations(integrations: List<File>)
+}

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

@@ -0,0 +1,14 @@
+package app.revanced.patcher
+
+import brut.androlib.apk.ApkInfo
+
+/**
+ * Metadata about a package.
+ */
+class PackageMetadata internal constructor(internal val apkInfo: ApkInfo) {
+    lateinit var packageName: String
+        internal set
+
+    lateinit var packageVersion: String
+        internal set
+}

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

@@ -0,0 +1,74 @@
+@file:Suppress("unused")
+
+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.DexClassLoader
+import lanchon.multidexlib2.BasicDexFileNamer
+import lanchon.multidexlib2.MultiDexIO
+import java.io.File
+import java.net.URLClassLoader
+import java.util.jar.JarFile
+
+/**
+ * A patch bundle.
+ *
+ * @param fromClasses The classes to get [Patch]es from.
+ */
+sealed class PatchBundleLoader private constructor(
+    fromClasses: Iterable<Class<*>>
+) : MutableList<PatchClass> by mutableListOf() {
+    init {
+        fromClasses.filter {
+            if (it.isAnnotation) return@filter false
+
+            it.findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class) != null
+        }.map {
+            @Suppress("UNCHECKED_CAST")
+            it as PatchClass
+        }.sortedBy {
+            it.patchName
+        }.let { addAll(it) }
+    }
+
+    /**
+     * A [PatchBundleLoader] for JAR files.
+     *
+     * @param patchBundles The path to patch bundles of JAR format.
+     */
+    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 { it.name.replace('/', '.').replace(".class", "") }
+                    .map { loadClass(it) }
+            }
+        })
+
+    /**
+     * A [PatchBundleLoader] for [Dex] files.
+     *
+     * @param patchBundles The path to patch bundles of DEX format.
+     */
+    class Dex(vararg patchBundles: File) : PatchBundleLoader(with(
+        DexClassLoader(
+            patchBundles.joinToString(File.pathSeparator) { it.absolutePath },
+            null,
+            null,
+            PatchBundleLoader::class.java.classLoader
+        )
+    ) {
+        patchBundles
+            .flatMap {
+                MultiDexIO.readDexFile(true, it, BasicDexFileNamer(), null, null).classes
+            }
+            .map { classDef -> classDef.type.substring(1, classDef.length - 1) }
+            .map { loadClass(it) }
+    })
+}

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

@@ -0,0 +1,8 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.patch.PatchResult
+import kotlinx.coroutines.flow.Flow
+import java.util.function.Function
+
+@FunctionalInterface
+interface PatchExecutorFunction : Function<Boolean, Flow<PatchResult>>

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

@@ -1,181 +1,67 @@
 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
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolve
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolveUsingLookupMap
 import app.revanced.patcher.patch.*
-import app.revanced.patcher.util.VersionReader
+import kotlinx.coroutines.flow.flow
-import brut.androlib.Androlib
-import brut.androlib.meta.UsesFramework
-import brut.androlib.options.BuildOptions
-import brut.androlib.res.AndrolibResources
-import brut.androlib.res.data.ResPackage
-import brut.androlib.res.decoder.AXmlResourceParser
-import brut.androlib.res.decoder.ResAttrDecoder
-import brut.androlib.res.decoder.XmlPullStreamDecoder
-import brut.androlib.res.xml.ResXmlPatcher
-import brut.directory.ExtFile
-import lanchon.multidexlib2.BasicDexFileNamer
-import lanchon.multidexlib2.DexIO
-import lanchon.multidexlib2.MultiDexIO
-import org.jf.dexlib2.Opcodes
-import org.jf.dexlib2.iface.DexFile
-import org.jf.dexlib2.writer.io.MemoryDataStore
 import java.io.Closeable
 import java.io.File
-import java.io.OutputStream
+import java.util.function.Supplier
-import java.nio.file.Files
+import java.util.logging.Level
-
+import java.util.logging.LogManager
-internal val NAMER = BasicDexFileNamer()
+import java.util.logging.Logger
 
 /**
- * The ReVanced Patcher.
+ * ReVanced Patcher.
+ *
  * @param options The options for the patcher.
  */
-class Patcher(private val options: PatcherOptions) {
+class Patcher(
-    private val logger = options.logger
+    private val options: PatcherOptions
-    private val opcodes: Opcodes
+) : PatchExecutorFunction, PatchesConsumer, IntegrationsConsumer, Supplier<PatcherResult>, Closeable {
-    private var resourceDecodingMode = ResourceDecodingMode.MANIFEST_ONLY
+    private val logger = Logger.getLogger(Patcher::class.java.name)
-    private var mergeIntegrations = false
-    val context: PatcherContext
 
-    companion object {
+    /**
-        @JvmStatic
+     * The context of ReVanced [Patcher].
-        val version = VersionReader.read()
+     * This holds the current state of the patcher.
-        private fun BuildOptions.setBuildOptions(options: PatcherOptions) {
+     */
-            this.aaptPath = options.aaptPath
+    val context = PatcherContext(options)
-            this.useAapt2 = true
-            this.frameworkFolderLocation = options.frameworkFolderLocation
-        }
-    }
 
     init {
-        logger.info("Reading dex files")
+        LogManager.getLogManager().let { manager ->
-        // read dex files
+            // Disable root logger.
-        val dexFile = MultiDexIO.readDexFile(true, options.inputFile, NAMER, null, null)
+            manager.getLogger("").level = Level.OFF
-        // get the opcodes
-        opcodes = dexFile.opcodes
-        // finally create patcher context
-        context = PatcherContext(dexFile.classes.toMutableList(), File(options.resourceCacheDirectory))
 
-        // decode manifest file
+            // Enable ReVanced logging only.
-        decodeResources(ResourceDecodingMode.MANIFEST_ONLY)
+            manager.loggerNames
-    }
+                .toList()
-
+                .filter { it.startsWith("app.revanced") }
-    /**
+                .map { manager.getLogger(it) }
-     * Add integrations to be merged by the patcher.
+                .forEach { it.level = Level.INFO }
-     * The integrations will only be merged, if necessary.
-     *
-     * @param integrations The integrations, must be dex files or dex file container such as ZIP, APK or DEX files.
-     * @param callback The callback for [integrations] which are being added.
-     */
-    fun addIntegrations(
-        integrations: List<File>,
-        callback: (File) -> Unit
-    ) {
-        context.integrations.apply integrations@{
-            add(integrations)
-            this@integrations.callback = callback
-        }
-    }
-
-    /**
-     * Save the patched dex file.
-     */
-    fun save(): PatcherResult {
-        val packageMetadata = context.packageMetadata
-        val metaInfo = packageMetadata.metaInfo
-        var resourceFile: File? = null
-
-        when (resourceDecodingMode) {
-            ResourceDecodingMode.FULL -> {
-                val cacheDirectory = ExtFile(options.resourceCacheDirectory)
-                try {
-                    val androlibResources = AndrolibResources().also { resources ->
-                        resources.buildOptions = BuildOptions().also { buildOptions ->
-                            buildOptions.setBuildOptions(options)
-                            buildOptions.isFramework = metaInfo.isFrameworkApk
-                            buildOptions.resourcesAreCompressed = metaInfo.compressionType
-                            buildOptions.doNotCompress = metaInfo.doNotCompress
-                        }
-
-                        resources.setSdkInfo(metaInfo.sdkInfo)
-                        resources.setVersionInfo(metaInfo.versionInfo)
-                        resources.setSharedLibrary(metaInfo.sharedLibrary)
-                        resources.setSparseResources(metaInfo.sparseResources)
-                    }
-
-                    val manifestFile = cacheDirectory.resolve("AndroidManifest.xml")
-
-                    ResXmlPatcher.fixingPublicAttrsInProviderAttributes(manifestFile)
-
-                    val aaptFile = cacheDirectory.resolve("aapt_temp_file")
-
-                    // delete if it exists
-                    Files.deleteIfExists(aaptFile.toPath())
-
-                    val resDirectory = cacheDirectory.resolve("res")
-                    val includedFiles = metaInfo.usesFramework.ids.map { id ->
-                        androlibResources.getFrameworkApk(
-                            id, metaInfo.usesFramework.tag
-                        )
-                    }.toTypedArray()
-
-                    logger.info("Compiling resources")
-                    androlibResources.aaptPackage(
-                        aaptFile, manifestFile, resDirectory, null, null, includedFiles
-                    )
-
-                    resourceFile = aaptFile
-                } finally {
-                    cacheDirectory.close()
-                }
-            }
-
-            else -> logger.info("Not compiling resources because resource patching is not required")
         }
 
-        logger.trace("Creating new dex file")
+        context.resourceContext.decodeResources(ResourceContext.ResourceDecodingMode.MANIFEST_ONLY)
-        val newDexFile = object : DexFile {
-            override fun getClasses() = context.bytecodeContext.classes.also { it.replaceClasses() }
-            override fun getOpcodes() = this@Patcher.opcodes
-        }
-
-        // write modified dex files
-        logger.info("Writing modified dex files")
-        val dexFiles = mutableMapOf<String, MemoryDataStore>()
-        MultiDexIO.writeDexFile(
-            true, -1, // core count
-            dexFiles, NAMER, newDexFile, DexIO.DEFAULT_MAX_DEX_POOL_SIZE, null
-        )
-
-        return PatcherResult(
-            dexFiles.map {
-                app.revanced.patcher.util.dex.DexFile(it.key, it.value.readAt(0))
-            },
-            metaInfo.doNotCompress?.toList(),
-            resourceFile
-        )
     }
 
-    /**
+    override fun acceptPatches(patches: List<PatchClass>) {
-     * Add [Patch]es to the patcher.
-     * @param patches [Patch]es The patches to add.
-     */
-    fun addPatches(patches: Iterable<Class<out Patch<Context>>>) {
         /**
          * Returns true if at least one patches or its dependencies matches the given predicate.
          */
-        fun Class<out Patch<Context>>.anyRecursively(predicate: (Class<out Patch<Context>>) -> Boolean): Boolean =
+        fun PatchClass.anyRecursively(predicate: (PatchClass) -> Boolean): Boolean =
-            predicate(this) || dependencies?.any { it.java.anyRecursively(predicate) } == true
+            predicate(this) || dependencies?.any { dependency ->
-
+                dependency.java.anyRecursively(predicate)
+            } ?: false
 
         // Determine if resource patching is required.
         for (patch in patches) {
             if (patch.anyRecursively { ResourcePatch::class.java.isAssignableFrom(it) }) {
-                resourceDecodingMode = ResourceDecodingMode.FULL
+                options.resourceDecodingMode = ResourceContext.ResourceDecodingMode.FULL
                 break
             }
         }
@@ -183,7 +69,7 @@ class Patcher(private val options: PatcherOptions) {
         // Determine if merging integrations is required.
         for (patch in patches) {
             if (patch.anyRecursively { it.requiresIntegrations }) {
-                mergeIntegrations = true
+                context.bytecodeContext.integrations.merge = true
                 break
             }
         }
@@ -192,225 +78,159 @@ class Patcher(private val options: PatcherOptions) {
     }
 
     /**
-     * Decode resources for the patcher.
+     * Add integrations to the [Patcher].
      *
-     * @param mode The [ResourceDecodingMode] to use when decoding.
+     * @param integrations The integrations to add. Must be a DEX file or container of DEX files.
      */
-    private fun decodeResources(mode: ResourceDecodingMode) {
+    override fun acceptIntegrations(integrations: List<File>) {
-        val extInputFile = ExtFile(options.inputFile)
+        context.bytecodeContext.integrations.addAll(integrations)
-        try {
-            val androlib = Androlib(BuildOptions().also { it.setBuildOptions(options) })
-            val resourceTable = androlib.getResTable(extInputFile, true)
-            when (mode) {
-                ResourceDecodingMode.FULL -> {
-                    val outDir = File(options.resourceCacheDirectory)
-                    if (outDir.exists()) {
-                        logger.info("Deleting existing resource cache directory")
-                        if (!outDir.deleteRecursively()) {
-                            logger.error("Failed to delete existing resource cache directory")
-                        }
-                    }
-                    outDir.mkdirs()
-
-                    logger.info("Decoding resources")
-
-                    // decode resources to cache directory
-                    androlib.decodeManifestWithResources(extInputFile, outDir, resourceTable)
-                    androlib.decodeResourcesFull(extInputFile, outDir, resourceTable)
-
-                    // read additional metadata from the resource table
-                    context.packageMetadata.let { metadata ->
-                        metadata.metaInfo.usesFramework = UsesFramework().also { framework ->
-                            framework.ids = resourceTable.listFramePackages().map { it.id }.sorted()
-                        }
-
-                        // read files to not compress
-                        metadata.metaInfo.doNotCompress = buildList {
-                            androlib.recordUncompressedFiles(extInputFile, this)
-                        }
-                    }
-
-                }
-
-                ResourceDecodingMode.MANIFEST_ONLY -> {
-                    logger.info("Decoding AndroidManifest.xml only, because resources are not needed")
-
-                    // create decoder for the resource table
-                    val decoder = ResAttrDecoder()
-                    decoder.currentPackage = ResPackage(resourceTable, 0, null)
-
-                    // create xml parser with the decoder
-                    val axmlParser = AXmlResourceParser()
-                    axmlParser.attrDecoder = decoder
-
-                    // parse package information with the decoder and parser which will set required values in the resource table
-                    // instead of decodeManifest another more low level solution can be created to make it faster/better
-                    XmlPullStreamDecoder(
-                        axmlParser, AndrolibResources().resXmlSerializer
-                    ).decodeManifest(
-                        extInputFile.directory.getFileInput("AndroidManifest.xml"),
-                        // Older Android versions do not support OutputStream.nullOutputStream()
-                        object : OutputStream() {
-                            override fun write(b: Int) {
-                                // do nothing
-                            }
-                        }
-                    )
-                }
-            }
-
-            // read of the resourceTable which is created by reading the manifest file
-            context.packageMetadata.let { metadata ->
-                metadata.packageName = resourceTable.currentResPackage.name
-                metadata.packageVersion = resourceTable.versionInfo.versionName ?: resourceTable.versionInfo.versionCode
-                metadata.metaInfo.versionInfo = resourceTable.versionInfo
-                metadata.metaInfo.sdkInfo = resourceTable.sdkInfo
-            }
-        } finally {
-            extInputFile.close()
-        }
     }
 
     /**
-     * Execute patches added the patcher.
+     * Execute [Patch]es that were added to ReVanced [Patcher].
      *
-     * @param stopOnError If true, the patches will stop on the first error.
+     * @param returnOnError If true, ReVanced [Patcher] will return immediately if a [Patch] fails.
      * @return A pair of the name of the [Patch] and its [PatchResult].
      */
-    fun executePatches(stopOnError: Boolean = false): Sequence<Pair<String, Result<PatchResultSuccess>>> {
+    override fun apply(returnOnError: Boolean) = flow {
+        class ExecutedPatch(val patchInstance: Patch<Context<*>>, val patchResult: PatchResult)
+
         /**
          * Execute a [Patch] and its dependencies recursively.
          *
          * @param patchClass The [Patch] to execute.
-         * @param executedPatches A map of [Patch]es paired to a boolean indicating their success, to prevent infinite recursion.
+         * @param executedPatches A map to prevent [Patch]es from being executed twice due to dependencies.
          * @return The result of executing the [Patch].
          */
         fun executePatch(
-            patchClass: Class<out Patch<Context>>,
+            patchClass: PatchClass,
             executedPatches: LinkedHashMap<String, ExecutedPatch>
         ): PatchResult {
             val patchName = patchClass.patchName
 
-            // if the patch has already applied silently skip it
+            executedPatches[patchName]?.let { executedPatch ->
-            if (executedPatches.contains(patchName)) {
+                executedPatch.patchResult.exception ?: return executedPatch.patchResult
-                if (!executedPatches[patchName]!!.success)
-                    return PatchResultError("'$patchName' did not succeed previously")
 
-                logger.trace("Skipping '$patchName' because it has already been applied")
+                // Return a new result with an exception indicating that the patch was not executed previously,
-
+                // because it is a dependency of another patch that failed.
-                return PatchResultSuccess()
+                return PatchResult(patchName, PatchException("'$patchName' did not succeed previously"))
             }
 
-            // recursively execute all dependency patches
+            // Recursively execute all dependency patches.
             patchClass.dependencies?.forEach { dependencyClass ->
                 val dependency = dependencyClass.java
 
                 val result = executePatch(dependency, executedPatches)
-                if (result.isSuccess()) return@forEach
 
-                return PatchResultError(
+                result.exception?.let {
-                    "'$patchName' depends on '${dependency.patchName}' but the following error was raised: " +
+                    return PatchResult(
-                            result.error()!!.let { it.cause?.stackTraceToString() ?: it.message }
+                        patchName,
-                )
+                        PatchException(
-            }
+                            "'$patchName' depends on '${dependency.patchName}' that raised an exception: $it"
-
+                        )
-            val isResourcePatch = ResourcePatch::class.java.isAssignableFrom(patchClass)
-            val patchInstance = patchClass.getDeclaredConstructor().newInstance()
-
-            // TODO: implement this in a more polymorphic way
-            val patchContext = if (isResourcePatch) {
-                context.resourceContext
-            } else {
-                context.bytecodeContext.also { context ->
-                    (patchInstance as BytecodePatch).fingerprints?.resolve(
-                        context,
-                        context.classes.classes
                     )
                 }
             }
 
-            logger.trace("Executing '$patchName' of type: ${if (isResourcePatch) "resource" else "bytecode"}")
+            // TODO: Implement this in a more polymorphic way.
+            val patchInstance = patchClass.getDeclaredConstructor().newInstance()
+
+            val patchContext = if (patchInstance is BytecodePatch) {
+                patchInstance.fingerprints?.resolveUsingLookupMap(context.bytecodeContext)
+
+                context.bytecodeContext
+            } else {
+                context.resourceContext
+            }
 
             return try {
-                patchInstance.execute(patchContext).also {
+                patchInstance.execute(patchContext)
-                    executedPatches[patchName] = ExecutedPatch(patchInstance, it.isSuccess())
+
-                }
+                PatchResult(patchName)
-            } catch (e: Exception) {
+            } catch (exception: PatchException) {
-                PatchResultError(e).also {
+                PatchResult(patchName, exception)
-                    executedPatches[patchName] = ExecutedPatch(patchInstance, false)
+            } catch (exception: Exception) {
-                }
+                PatchResult(patchName, PatchException(exception))
+            }.also { executedPatches[patchName] = ExecutedPatch(patchInstance, it) }
+        }
+
+        if (context.bytecodeContext.integrations.merge) context.bytecodeContext.integrations.flush()
+
+        MethodFingerprint.initializeFingerprintResolutionLookupMaps(context.bytecodeContext)
+
+        // Prevent from decoding the app manifest twice if it is not needed.
+        if (options.resourceDecodingMode == ResourceContext.ResourceDecodingMode.FULL)
+            context.resourceContext.decodeResources(ResourceContext.ResourceDecodingMode.FULL)
+
+        logger.info("Executing patches")
+
+        val executedPatches = LinkedHashMap<String, ExecutedPatch>() // Key is name.
+
+        context.patches.forEach { patch ->
+            val result = executePatch(patch, executedPatches)
+
+            // If the patch failed, or if the patch is not closeable, emit the result.
+            // Results of patches that are closeable will be emitted later.
+            result.exception?.let {
+                emit(result)
+
+                if (returnOnError) return@flow
+            } ?: run {
+                if (executedPatches[result.patchName]!!.patchInstance is Closeable) return@run
+
+                emit(result)
             }
         }
 
-        return sequence {
+        executedPatches.values
-            if (mergeIntegrations) context.integrations.merge(logger)
+            .filter { it.patchResult.exception == null }
+            .filter { it.patchInstance is Closeable }.asReversed().forEach { executedPatch ->
+                val patchName = executedPatch.patchResult.patchName
 
-            // prevent from decoding the manifest twice if it is not needed
+                val result = try {
-            if (resourceDecodingMode == ResourceDecodingMode.FULL) decodeResources(ResourceDecodingMode.FULL)
+                    (executedPatch.patchInstance as Closeable).close()
 
-            logger.trace("Executing all patches")
+                    executedPatch.patchResult
-
+                } catch (exception: PatchException) {
-            val executedPatches = LinkedHashMap<String, ExecutedPatch>() // first is name
+                    PatchResult(patchName, exception)
-
+                } catch (exception: Exception) {
-
+                    PatchResult(patchName, PatchException(exception))
-            context.patches.forEach { patch ->
-                val patchResult = executePatch(patch, executedPatches)
-
-                val result = if (patchResult.isSuccess()) {
-                    Result.success(patchResult.success()!!)
-                } else {
-                    Result.failure(patchResult.error()!!)
                 }
 
-                // TODO: This prints before the patch really finishes in case it is a Closeable
+                result.exception?.let {
-                //  because the Closeable is closed after all patches are executed.
+                    emit(
-                yield(patch.patchName to result)
+                        PatchResult(
+                            patchName,
+                            PatchException("'$patchName' raised an exception while being closed: $it")
+                        )
+                    )
 
-                if (stopOnError && patchResult.isError()) return@sequence
+                    if (returnOnError) return@flow
+                } ?: run {
+                    executedPatch
+                        .patchInstance::class
+                        .java
+                        .findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class)
+                        ?: return@run
+
+                    emit(result)
+                }
             }
+    }
 
-            executedPatches.values
+    override fun close() {
-                .filter(ExecutedPatch::success)
+        MethodFingerprint.clearFingerprintResolutionLookupMaps()
-                .map(ExecutedPatch::patchInstance)
-                .filterIsInstance(Closeable::class.java)
-                .asReversed().forEach {
-                    try {
-                        it.close()
-                    } catch (exception: Exception) {
-                        val patchName = (it as Patch<Context>).javaClass.patchName
-
-                        logger.error("Failed to close '$patchName': ${exception.stackTraceToString()}")
-
-                        yield(patchName to Result.failure(exception))
-
-                        // This is not failsafe. If a patch throws an exception while closing,
-                        // the other patches that depend on it may fail.
-                        if (stopOnError) return@sequence
-                    }
-                }
-        }
     }
 
     /**
-     * The type of decoding the resources.
+     * Compile and save the patched APK file.
+     *
+     * @return The [PatcherResult] containing the patched input files.
      */
-    private enum class ResourceDecodingMode {
+    override fun get() = PatcherResult(
-        /**
+        context.bytecodeContext.get(),
-         * Decode all resources.
+        context.resourceContext.get(),
-         */
+        context.packageMetadata.apkInfo.doNotCompress?.toList()
-        FULL,
+    )
-
-        /**
-         * Decode the manifest file only.
-         */
-        MANIFEST_ONLY,
-    }
 }
 
-/**
- * A result of executing a [Patch].
- *
- * @param patchInstance The instance of the [Patch] that was applied.
- * @param success The result of the [Patch].
- */
-internal data class ExecutedPatch(val patchInstance: Patch<Context>, val success: Boolean)

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

@@ -1,64 +1,37 @@
 package app.revanced.patcher
 
-import app.revanced.patcher.data.*
+import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.logging.Logger
+import app.revanced.patcher.data.ResourceContext
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.util.ClassMerger.merge
+import app.revanced.patcher.patch.PatchClass
-import org.jf.dexlib2.iface.ClassDef
+import brut.androlib.apk.ApkInfo
-import java.io.File
+import brut.directory.ExtFile
 
-data class PatcherContext(
+/**
-    val classes: MutableList<ClassDef>,
+ * A context for ReVanced [Patcher].
-    val resourceCacheDirectory: File,
+ *
-) {
+ * @param options The [PatcherOptions] used to create this context.
-    val packageMetadata = PackageMetadata()
+ */
-    internal val patches = mutableListOf<Class<out Patch<Context>>>()
+class PatcherContext internal constructor(options: PatcherOptions) {
-    internal val integrations = Integrations(this)
+    /**
-    internal val bytecodeContext = BytecodeContext(classes)
+     * [PackageMetadata] of the supplied [PatcherOptions.inputFile].
-    internal val resourceContext = ResourceContext(resourceCacheDirectory)
+     */
+    val packageMetadata = PackageMetadata(ApkInfo(ExtFile(options.inputFile)))
 
-    internal class Integrations(val context: PatcherContext) {
+    /**
-        var callback: ((File) -> Unit)? = null
+     * The list of [Patch]es to execute.
-        private val integrations: MutableList<File> = mutableListOf()
+     */
+    internal val patches = mutableListOf<PatchClass>()
 
-        fun add(integrations: List<File>) = this@Integrations.integrations.addAll(integrations)
+    /**
+     * The [ResourceContext] of this [PatcherContext].
+     * This holds the current state of the resources.
+     */
+    internal val resourceContext = ResourceContext(this, options)
 
-        /**
+    /**
-         * Merge integrations.
+     * The [BytecodeContext] of this [PatcherContext].
-         * @param logger A logger.
+     * This holds the current state of the bytecode.
-         */
+     */
-        fun merge(logger: Logger) {
+    internal val bytecodeContext = BytecodeContext(options)
-            with(context.bytecodeContext.classes) {
-                for (integrations in integrations) {
-                    callback?.let { it(integrations) }
-
-                    for (classDef in lanchon.multidexlib2.MultiDexIO.readDexFile(
-                        true,
-                        integrations,
-                        NAMER,
-                        null,
-                        null
-                    ).classes) {
-                        val type = classDef.type
-
-                        val result = classes.findIndexed { it.type == type }
-                        if (result == null) {
-                            logger.trace("Merging type $type")
-                            classes.add(classDef)
-                            continue
-                        }
-
-                        val (existingClass, existingClassIndex) = result
-
-                        logger.trace("Type $type exists. Adding missing methods and fields.")
-
-                        existingClass.merge(classDef, context, logger).let { mergedClass ->
-                            if (mergedClass !== existingClass) // referential equality check
-                                classes[existingClassIndex] = mergedClass
-                        }
-                    }
-                }
-            }
-        }
-    }
 }

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

@@ -1,21 +1,73 @@
 package app.revanced.patcher
 
-import app.revanced.patcher.logging.Logger
+import app.revanced.patcher.data.ResourceContext
 import app.revanced.patcher.logging.impl.NopLogger
+import brut.androlib.Config
 import java.io.File
+import java.util.logging.Logger
 
 /**
- * Options for the [Patcher].
+ * Options for ReVanced [Patcher].
- * @param inputFile The input file (usually an apk file).
+ * @param inputFile The input file to patch.
- * @param resourceCacheDirectory Directory to cache resources.
+ * @param resourceCachePath The path to the directory to use for caching resources.
- * @param aaptPath Optional path to a custom aapt binary.
+ * @param aaptBinaryPath The path to a custom aapt binary.
- * @param frameworkFolderLocation Optional path to a custom framework folder.
+ * @param frameworkFileDirectory The path to the directory to cache the framework file in.
- * @param logger Custom logger implementation for the [Patcher].
+ * @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 resourceCacheDirectory: String,
+    internal val resourceCachePath: File = File("revanced-resource-cache"),
-    internal val aaptPath: String? = null,
+    internal val aaptBinaryPath: String? = null,
-    internal val frameworkFolderLocation: 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
+     */
+    internal var resourceDecodingMode = ResourceContext.ResourceDecodingMode.MANIFEST_ONLY
+
+    /**
+     * The configuration to use for resource decoding and compiling.
+     */
+    internal val resourceConfig = Config.getDefaultConfig().apply {
+        useAapt2 = true
+        aaptPath = aaptBinaryPath ?: ""
+        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.severe("Failed to delete existing resource cache directory")
+        }
+
+        it.mkdirs()
+    }
+}

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

@@ -1,16 +1,23 @@
 package app.revanced.patcher
 
-import app.revanced.patcher.util.dex.DexFile
 import java.io.File
+import java.io.InputStream
 
 /**
  * The result of a patcher.
  * @param dexFiles The patched dex files.
- * @param doNotCompress List of relative paths to files to exclude from compressing.
  * @param resourceFile File containing resources that need to be extracted into the APK.
+ * @param doNotCompress List of relative paths of files to exclude from compressing.
  */
 data class PatcherResult(
-    val dexFiles: List<DexFile>,
+    val dexFiles: List<PatchedDexFile>,
-    val doNotCompress: List<String>? = null,
+    val resourceFile: File?,
-    val resourceFile: File?
+    val doNotCompress: List<String>? = null
-)
+) {
+    /**
+     * Wrapper for dex files.
+     * @param name The original name of the dex file.
+     * @param stream The dex file as [InputStream].
+     */
+    class PatchedDexFile(val name: String, val stream: InputStream)
+}

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

@@ -0,0 +1,8 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.patch.PatchClass
+
+@FunctionalInterface
+interface PatchesConsumer {
+    fun acceptPatches(patches: List<PatchClass>)
+}

src/main/kotlin/app/revanced/patcher/annotation/MetadataAnnotation.kt

@@ -18,14 +18,4 @@ annotation class Name(
 @Target(AnnotationTarget.CLASS)
 annotation class Description(
     val description: String,
-)
+)
-
-
-/**
- * Annotation to version a [Patch].
- * @param version The version of a [Patch].
- */
-@Target(AnnotationTarget.CLASS)
-annotation class Version(
-    val version: String,
-)

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

@@ -0,0 +1,157 @@
+package app.revanced.patcher.data
+
+import app.revanced.patcher.PatcherContext
+import app.revanced.patcher.PatcherOptions
+import app.revanced.patcher.PatcherResult
+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
+import app.revanced.patcher.util.proxy.ClassProxy
+import com.android.tools.smali.dexlib2.Opcodes
+import com.android.tools.smali.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.DexFile
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.writer.io.MemoryDataStore
+import lanchon.multidexlib2.BasicDexFileNamer
+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.
+ * This holds the current state of the bytecode.
+ *
+ * @param options The [PatcherOptions] used to create this context.
+ */
+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].
+     */
+    internal lateinit var opcodes: Opcodes
+
+    /**
+     * The list of classes.
+     */
+    val classes by lazy {
+        ProxyClassList(
+            MultiDexIO.readDexFile(
+                true, options.inputFile, BasicDexFileNamer(), null, null
+            ).also { opcodes = it.opcodes }.classes.toMutableSet()
+        )
+    }
+
+    /**
+     * The [Integrations] of this [PatcherContext].
+     */
+    internal val integrations = Integrations()
+
+    /**
+     * Find a class by a given class name.
+     *
+     * @param className The name of the class.
+     * @return A proxy for the first class that matches the class name.
+     */
+    fun findClass(className: String) = findClass { it.type.contains(className) }
+
+    /**
+     * Find a class by a given predicate.
+     *
+     * @param predicate A predicate to match the class.
+     * @return A proxy for the first class that matches the predicate.
+     */
+    fun findClass(predicate: (ClassDef) -> Boolean) =
+        // if we already proxied the class matching the predicate...
+        classes.proxies.firstOrNull { predicate(it.immutableClass) } ?:
+        // else resolve the class to a proxy and return it, if the predicate is matching a class
+        classes.find(predicate)?.let { proxy(it) }
+
+    /**
+     * Proxy a class.
+     * This will allow the class to be modified.
+     *
+     * @param classDef The class to proxy.
+     * @return A proxy for the class.
+     */
+    fun proxy(classDef: ClassDef) = this.classes.proxies.find { it.immutableClass.type == classDef.type } ?: let {
+        ClassProxy(classDef).also { this.classes.add(it) }
+    }
+
+    /**
+     * Create a [MethodWalker] instance for the current [BytecodeContext].
+     *
+     * @param startMethod The method to start at.
+     * @return A [MethodWalker] instance.
+     */
+    fun toMethodWalker(startMethod: Method) = MethodWalker(this, startMethod)
+
+    /**
+     * The integrations of a [PatcherContext].
+     */
+    internal inner class Integrations : MutableList<File> by mutableListOf(), Flushable {
+        /**
+         * Whether to merge integrations.
+         * True when any supplied [Patch] is annotated with [RequiresIntegrations].
+         */
+        var merge = false
+
+        /**
+         * Merge integrations into the [BytecodeContext] and flush all [Integrations].
+         */
+        override fun flush() {
+            if (!merge) return
+
+            logger.info("Merging integrations")
+
+            this@Integrations.forEach { integrations ->
+                MultiDexIO.readDexFile(
+                    true,
+                    integrations, BasicDexFileNamer(),
+                    null,
+                    null
+                ).classes.forEach classDef@{ classDef ->
+                    val existingClass = classes.find { it == classDef } ?: run {
+                        logger.fine("Merging $classDef")
+                        classes.add(classDef)
+                        return@classDef
+                    }
+
+                    logger.fine("$classDef exists. Adding missing methods and fields.")
+
+                    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) }
+                    }
+                }
+            }
+
+            clear()
+        }
+    }
+
+    /**
+     * Compile bytecode from the [BytecodeContext].
+     *
+     * @return The compiled bytecode.
+     */
+    override fun get(): List<PatcherResult.PatchedDexFile> {
+        logger.info("Compiling modified dex files")
+
+        return mutableMapOf<String, MemoryDataStore>().apply {
+            MultiDexIO.writeDexFile(
+                true, -1, // Defaults to amount of available cores.
+                this, BasicDexFileNamer(), object : DexFile {
+                    override fun getClasses() = this@BytecodeContext.classes.also(ProxyClassList::replaceClasses)
+                    override fun getOpcodes() = this@BytecodeContext.opcodes
+                }, DexIO.DEFAULT_MAX_DEX_POOL_SIZE, null
+            )
+        }.map { PatcherResult.PatchedDexFile(it.key, it.value.readAt(0)) }
+    }
+}

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

@@ -1,170 +1,9 @@
 package app.revanced.patcher.data
 
-import app.revanced.patcher.util.ProxyBackedClassList
+import java.util.function.Supplier
-import app.revanced.patcher.util.method.MethodWalker
-import org.jf.dexlib2.iface.ClassDef
-import org.jf.dexlib2.iface.Method
-import org.w3c.dom.Document
-import java.io.Closeable
-import java.io.File
-import java.io.InputStream
-import java.io.OutputStream
-import javax.xml.parsers.DocumentBuilderFactory
-import javax.xml.transform.TransformerFactory
-import javax.xml.transform.dom.DOMSource
-import javax.xml.transform.stream.StreamResult
 
 /**
- * A common interface to constrain [Context] to [BytecodeContext] and [ResourceContext].
+ * A common interface for contexts such as [ResourceContext] and [BytecodeContext].
  */
 
-sealed interface Context
+sealed interface Context<T> : Supplier<T>
-
-class BytecodeContext internal constructor(classes: MutableList<ClassDef>) : Context {
-    /**
-     * The list of classes.
-     */
-    val classes = ProxyBackedClassList(classes)
-
-    /**
-     * Find a class by a given class name.
-     *
-     * @param className The name of the class.
-     * @return A proxy for the first class that matches the class name.
-     */
-    fun findClass(className: String) = findClass { it.type.contains(className) }
-
-    /**
-     * Find a class by a given predicate.
-     *
-     * @param predicate A predicate to match the class.
-     * @return A proxy for the first class that matches the predicate.
-     */
-    fun findClass(predicate: (ClassDef) -> Boolean) =
-        // if we already proxied the class matching the predicate...
-        classes.proxies.firstOrNull { predicate(it.immutableClass) } ?:
-        // else resolve the class to a proxy and return it, if the predicate is matching a class
-        classes.find(predicate)?.let { proxy(it) }
-
-    fun proxy(classDef: ClassDef): app.revanced.patcher.util.proxy.ClassProxy {
-        var proxy = this.classes.proxies.find { it.immutableClass.type == classDef.type }
-        if (proxy == null) {
-            proxy = app.revanced.patcher.util.proxy.ClassProxy(classDef)
-            this.classes.add(proxy)
-        }
-        return proxy
-    }
-}
-
-/**
- * Create a [MethodWalker] instance for the current [BytecodeContext].
- *
- * @param startMethod The method to start at.
- * @return A [MethodWalker] instance.
- */
-fun BytecodeContext.toMethodWalker(startMethod: Method): MethodWalker {
-    return MethodWalker(this, startMethod)
-}
-
-internal inline fun <T> Iterable<T>.findIndexed(predicate: (T) -> Boolean): Pair<T, Int>? {
-    for ((index, element) in this.withIndex()) {
-        if (predicate(element)) {
-            return element to index
-        }
-    }
-    return null
-}
-
-class ResourceContext internal constructor(private val resourceCacheDirectory: File) : Context, Iterable<File> {
-    val xmlEditor = XmlFileHolder()
-
-    operator fun get(path: String) = resourceCacheDirectory.resolve(path)
-
-    override fun iterator() = resourceCacheDirectory.walkTopDown().iterator()
-
-    inner class XmlFileHolder {
-        operator fun get(inputStream: InputStream) =
-            DomFileEditor(inputStream)
-
-        operator fun get(path: String): DomFileEditor {
-            return DomFileEditor(this@ResourceContext[path])
-        }
-
-    }
-}
-
-/**
- * Wrapper for a file that can be edited as a dom document.
- *
- * This constructor does not check for locks to the file when writing.
- * Use the secondary constructor.
- *
- * @param inputStream the input stream to read the xml file from.
- * @param outputStream the output stream to write the xml file to. If null, the file will be read only.
- *
- */
-class DomFileEditor internal constructor(
-    private val inputStream: InputStream,
-    private val outputStream: Lazy<OutputStream>? = null,
-) : Closeable {
-    // path to the xml file to unlock the resource when closing the editor
-    private var filePath: String? = null
-    private var closed: Boolean = false
-
-    /**
-     * The document of the xml file
-     */
-    val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
-        .also(Document::normalize)
-
-
-    // lazily open an output stream
-    // this is required because when constructing a DomFileEditor the output stream is created along with the input stream, which is not allowed
-    // the workaround is to lazily create the output stream. This way it would be used after the input stream is closed, which happens in the constructor
-    constructor(file: File) : this(file.inputStream(), lazy { file.outputStream() }) {
-        // increase the lock
-        locks.merge(file.path, 1, Integer::sum)
-        filePath = file.path
-    }
-
-    /**
-     * Closes the editor. Write backs and decreases the lock count.
-     *
-     * Will not write back to the file if the file is still locked.
-     */
-    override fun close() {
-        if (closed) return
-
-        inputStream.close()
-
-        // if the output stream is not null, do not close it
-        outputStream?.let {
-            // prevent writing to same file, if it is being locked
-            // isLocked will be false if the editor was created through a stream
-            val isLocked = filePath?.let { path ->
-                val isLocked = locks[path]!! > 1
-                // decrease the lock count if the editor was opened for a file
-                locks.merge(path, -1, Integer::sum)
-                isLocked
-            } ?: false
-
-            // if unlocked, write back to the file
-            if (!isLocked) {
-                it.value.use { stream ->
-                    val result = StreamResult(stream)
-                    TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), result)
-                }
-
-                it.value.close()
-                return
-            }
-        }
-
-        closed = true
-    }
-
-    private companion object {
-        // map of concurrent open files
-        val locks = mutableMapOf<String, Int>()
-    }
-}

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

@@ -1,13 +0,0 @@
-package app.revanced.patcher.data
-
-import brut.androlib.meta.MetaInfo
-
-/**
- * Metadata about a package.
- */
-class PackageMetadata {
-    lateinit var packageName: String
-    lateinit var packageVersion: String
-
-    internal val metaInfo: MetaInfo = MetaInfo()
-}

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

@@ -0,0 +1,160 @@
+package app.revanced.patcher.data
+
+import app.revanced.patcher.PatcherContext
+import app.revanced.patcher.PatcherOptions
+import app.revanced.patcher.util.DomFileEditor
+import brut.androlib.AaptInvoker
+import brut.androlib.ApkDecoder
+import brut.androlib.apk.UsesFramework
+import brut.androlib.res.Framework
+import brut.androlib.res.ResourcesDecoder
+import brut.androlib.res.decoder.AndroidManifestResourceParser
+import brut.androlib.res.decoder.XmlPullStreamDecoder
+import brut.androlib.res.xml.ResXmlPatcher
+import brut.directory.ExtFile
+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.
+ * This holds the current state of the resources.
+ *
+ * @param context The [PatcherContext] to create the context for.
+ */
+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()
+
+    /**
+     * Decode resources for the patcher.
+     *
+     * @param mode The [ResourceDecodingMode] to use when decoding.
+     */
+    internal fun decodeResources(mode: ResourceDecodingMode) = with(context.packageMetadata.apkInfo) {
+        // Needed to decode resources.
+        val resourcesDecoder = ResourcesDecoder(options.resourceConfig, this)
+
+        when (mode) {
+            ResourceDecodingMode.FULL -> {
+                val outDir = options.recreateResourceCacheDirectory()
+
+                logger.info("Decoding resources")
+
+                resourcesDecoder.decodeResources(outDir)
+                resourcesDecoder.decodeManifest(outDir)
+
+                // Needed to record uncompressed files.
+                val apkDecoder = ApkDecoder(options.resourceConfig, this)
+                apkDecoder.recordUncompressedFiles(resourcesDecoder.resFileMapping)
+
+                usesFramework = UsesFramework().apply {
+                    ids = resourcesDecoder.resTable.listFramePackages().map { it.id }
+                }
+            }
+
+            ResourceDecodingMode.MANIFEST_ONLY -> {
+                logger.info("Decoding app manifest")
+
+                // Decode manually instead of using resourceDecoder.decodeManifest
+                // because it does not support decoding to an OutputStream.
+                XmlPullStreamDecoder(
+                    AndroidManifestResourceParser(resourcesDecoder.resTable),
+                    resourcesDecoder.resXmlSerializer
+                ).decodeManifest(
+                    apkFile.directory.getFileInput("AndroidManifest.xml"),
+                    // Older Android versions do not support OutputStream.nullOutputStream()
+                    object : OutputStream() {
+                        override fun write(b: Int) { /* do nothing */
+                        }
+                    }
+                )
+
+                // Get the package name and version from the manifest using the XmlPullStreamDecoder.
+                // XmlPullStreamDecoder.decodeManifest() sets metadata.apkInfo.
+                context.packageMetadata.let { metadata ->
+                    metadata.packageName = resourcesDecoder.resTable.packageRenamed
+                    versionInfo.let {
+                        metadata.packageVersion = it.versionName ?: it.versionCode
+                    }
+                }
+            }
+        }
+
+    }
+
+    operator fun get(path: String) = options.resourceCachePath.resolve(path)
+
+    override fun iterator() = options.resourceCachePath.walkTopDown().iterator()
+
+
+    /**
+     * Compile resources from the [ResourceContext].
+     *
+     * @return The compiled resources.
+     */
+    override fun get(): File? {
+        var resourceFile: File? = null
+
+        if (options.resourceDecodingMode == ResourceDecodingMode.FULL) {
+            logger.info("Compiling modified resources")
+
+            val cacheDirectory = ExtFile(options.resourceCachePath)
+            val aaptFile = cacheDirectory.resolve("aapt_temp_file").also {
+                Files.deleteIfExists(it.toPath())
+            }.also { resourceFile = it }
+
+            try {
+                AaptInvoker(
+                    options.resourceConfig, context.packageMetadata.apkInfo
+                ).invokeAapt(aaptFile,
+                    cacheDirectory.resolve("AndroidManifest.xml").also {
+                        ResXmlPatcher.fixingPublicAttrsInProviderAttributes(it)
+                    },
+                    cacheDirectory.resolve("res"),
+                    null,
+                    null,
+                    context.packageMetadata.apkInfo.usesFramework.let { usesFramework ->
+                        usesFramework.ids.map { id ->
+                            Framework(options.resourceConfig).getFrameworkApk(id, usesFramework.tag)
+                        }.toTypedArray()
+                    })
+            } finally {
+                cacheDirectory.close()
+            }
+        }
+
+        return resourceFile
+    }
+
+    /**
+     * The type of decoding the resources.
+     */
+    internal enum class ResourceDecodingMode {
+        /**
+         * Decode all resources.
+         */
+        FULL,
+
+        /**
+         * Decode the manifest file only.
+         */
+        MANIFEST_ONLY,
+    }
+
+    inner class XmlFileHolder {
+        operator fun get(inputStream: InputStream) =
+            DomFileEditor(inputStream)
+
+        operator fun get(path: String): DomFileEditor {
+            return DomFileEditor(this@ResourceContext[path])
+        }
+
+    }
+}

src/main/kotlin/app/revanced/patcher/extensions/Extensions.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.extensions
 
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import org.jf.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.AccessFlags
 
 /**
  * Create a label for the instruction at given index.

src/main/kotlin/app/revanced/patcher/extensions/InstructionExtensions.kt

@@ -4,12 +4,12 @@ import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
 import app.revanced.patcher.util.smali.ExternalLabel
 import app.revanced.patcher.util.smali.toInstruction
 import app.revanced.patcher.util.smali.toInstructions
-import org.jf.dexlib2.builder.BuilderInstruction
+import com.android.tools.smali.dexlib2.builder.BuilderInstruction
-import org.jf.dexlib2.builder.BuilderOffsetInstruction
+import com.android.tools.smali.dexlib2.builder.BuilderOffsetInstruction
-import org.jf.dexlib2.builder.Label
+import com.android.tools.smali.dexlib2.builder.Label
-import org.jf.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
-import org.jf.dexlib2.builder.instruction.*
+import com.android.tools.smali.dexlib2.builder.instruction.*
-import org.jf.dexlib2.iface.instruction.Instruction
+import com.android.tools.smali.dexlib2.iface.instruction.Instruction
 
 object InstructionExtensions {
 
@@ -22,8 +22,7 @@ object InstructionExtensions {
     fun MutableMethodImplementation.addInstructions(
         index: Int,
         instructions: List<BuilderInstruction>
-    ) =
+    ) = instructions.asReversed().forEach { addInstruction(index, it) }
-        instructions.asReversed().forEach { addInstruction(index, it) }
 
     /**
      * Add instructions to a method.
@@ -321,6 +320,11 @@ object InstructionExtensions {
      * @param T The type of instruction to return.
      * @return The instruction.
      */
-    @Suppress("UNCHECKED_CAST")
     fun <T> MutableMethod.getInstruction(index: Int): T = implementation!!.getInstruction<T>(index)
+
+    /**
+     * Get the instructions of a method.
+     * @return The instructions.
+     */
+    fun MutableMethod.getInstructions(): MutableList<BuilderInstruction> = implementation!!.instructions
 }

src/main/kotlin/app/revanced/patcher/extensions/PatchExtensions.kt

@@ -3,11 +3,10 @@ package app.revanced.patcher.extensions
 import app.revanced.patcher.annotation.Compatibility
 import app.revanced.patcher.annotation.Description
 import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.annotation.Version
-import app.revanced.patcher.data.Context
 import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
 import app.revanced.patcher.patch.OptionsContainer
 import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.PatchClass
 import app.revanced.patcher.patch.PatchOptions
 import app.revanced.patcher.patch.annotations.DependsOn
 import app.revanced.patcher.patch.annotations.RequiresIntegrations
@@ -19,49 +18,43 @@ object PatchExtensions {
     /**
      * The name of a [Patch].
      */
-    val Class<out Patch<Context>>.patchName: String
+    val PatchClass.patchName: String
         get() = findAnnotationRecursively(Name::class)?.name ?: this.simpleName
 
-    /**
-     * The version of a [Patch].
-     */
-    val Class<out Patch<Context>>.version
-        get() = findAnnotationRecursively(Version::class)?.version
-
     /**
      * Weather or not a [Patch] should be included.
      */
-    val Class<out Patch<Context>>.include
+    val PatchClass.include
         get() = findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class)!!.include
 
     /**
      * The description of a [Patch].
      */
-    val Class<out Patch<Context>>.description
+    val PatchClass.description
         get() = findAnnotationRecursively(Description::class)?.description
 
     /**
      * The dependencies of a [Patch].
      */
-    val Class<out Patch<Context>>.dependencies
+    val PatchClass.dependencies
         get() = findAnnotationRecursively(DependsOn::class)?.dependencies
 
     /**
      * The packages a [Patch] is compatible with.
      */
-    val Class<out Patch<Context>>.compatiblePackages
+    val PatchClass.compatiblePackages
         get() = findAnnotationRecursively(Compatibility::class)?.compatiblePackages
 
     /**
      * Weather or not a [Patch] requires integrations.
      */
-    internal val Class<out Patch<Context>>.requiresIntegrations
+    internal val PatchClass.requiresIntegrations
         get() = findAnnotationRecursively(RequiresIntegrations::class) != null
 
     /**
      * The options of a [Patch].
      */
-    val Class<out Patch<Context>>.options: PatchOptions?
+    val PatchClass.options: PatchOptions?
         get() = kotlin.companionObject?.let { cl ->
             if (cl.visibility != KVisibility.PUBLIC) return null
             kotlin.companionObjectInstance?.let {

src/main/kotlin/app/revanced/patcher/fingerprint/method/impl/MethodFingerprint.kt

@@ -4,27 +4,31 @@ import app.revanced.patcher.data.BytecodeContext
 import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyPatternScanMethod
 import app.revanced.patcher.fingerprint.Fingerprint
 import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.patch.PatchException
 import app.revanced.patcher.util.proxy.ClassProxy
-import org.jf.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.AccessFlags
-import org.jf.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.Opcode
-import org.jf.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.ClassDef
-import org.jf.dexlib2.iface.instruction.Instruction
+import com.android.tools.smali.dexlib2.iface.Method
-import org.jf.dexlib2.iface.instruction.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.instruction.Instruction
-import org.jf.dexlib2.iface.reference.StringReference
+import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
-import org.jf.dexlib2.util.MethodUtil
+import com.android.tools.smali.dexlib2.iface.reference.StringReference
+import com.android.tools.smali.dexlib2.util.MethodUtil
+import java.util.*
 
 private typealias StringMatch = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult.StringMatch
 private typealias StringsScanResult = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult
+private typealias MethodClassPair = Pair<Method, ClassDef>
 
 /**
- * Represents the [MethodFingerprint] for a method.
+ * A fingerprint to resolve methods.
- * @param returnType The return type of the method.
+ *
- * @param accessFlags The access flags of the method.
+ * @param returnType The method's return type compared using [String.startsWith].
- * @param parameters The parameters of the method.
+ * @param accessFlags The method's exact access flags using values of [AccessFlags].
- * @param opcodes The list of opcodes of the method.
+ * @param parameters The parameters of the method. Partial matches allowed and follow the same rules as [returnType].
- * @param strings A list of strings which a method contains.
+ * @param opcodes An opcode pattern of the method's instructions. Wildcard or unknown opcodes can be specified by `null`.
+ * @param strings A list of the method's strings compared each using [String.contains].
  * @param customFingerprint A custom condition for this fingerprint.
- * A `null` opcode is equals to an unknown opcode.
  */
 abstract class MethodFingerprint(
     internal val returnType: String? = null,
@@ -40,6 +44,201 @@ abstract class MethodFingerprint(
     var result: MethodFingerprintResult? = null
 
     companion object {
+        /**
+         * A list of methods and the class they were found in.
+         */
+        private val methods = mutableListOf<MethodClassPair>()
+
+        /**
+         * Lookup map for methods keyed to the methods access flags, return type and parameter.
+         */
+        private val methodSignatureLookupMap = mutableMapOf<String, MutableList<MethodClassPair>>()
+
+        /**
+         * Lookup map for methods keyed to the strings contained in the method.
+         */
+        private val methodStringsLookupMap = mutableMapOf<String, MutableList<MethodClassPair>>()
+
+        /**
+         * Appends a string based on the parameter reference types of this method.
+         */
+        private fun StringBuilder.appendParameters(parameters: Iterable<CharSequence>) {
+            // Maximum parameters to use in the signature key.
+            // Some apps have methods with an incredible number of parameters (over 100 parameters have been seen).
+            // To keep the signature map from becoming needlessly bloated,
+            // group together in the same map entry all methods with the same access/return and 5 or more parameters.
+            // The value of 5 was chosen based on local performance testing and is not set in stone.
+            val maxSignatureParameters = 5
+            // Must append a unique value before the parameters to distinguish this key includes the parameters.
+            // If this is not appended, then methods with no parameters
+            // will collide with different keys that specify access/return but omit the parameters.
+            append("p:")
+            parameters.forEachIndexed { index, parameter ->
+                if (index >= maxSignatureParameters) return
+                append(parameter.first())
+            }
+        }
+
+        /**
+         * Initializes lookup maps for [MethodFingerprint] resolution
+         * using attributes of methods such as the method signature or strings.
+         *
+         * @param context The [BytecodeContext] containing the classes to initialize the lookup maps with.
+         */
+        internal fun initializeFingerprintResolutionLookupMaps(context: BytecodeContext) {
+            fun MutableMap<String, MutableList<MethodClassPair>>.add(
+                key: String,
+                methodClassPair: MethodClassPair
+            ) {
+                var methodClassPairs = this[key]
+
+                methodClassPairs ?: run {
+                    methodClassPairs = LinkedList<MethodClassPair>().also { this[key] = it }
+                }
+
+                methodClassPairs!!.add(methodClassPair)
+            }
+
+            if (methods.isNotEmpty()) clearFingerprintResolutionLookupMaps()
+
+            context.classes.forEach { classDef ->
+                classDef.methods.forEach { method ->
+                    val methodClassPair = method to classDef
+
+                    // For fingerprints with no access or return type specified.
+                    methods += methodClassPair
+
+                    val accessFlagsReturnKey = method.accessFlags.toString() + method.returnType.first()
+
+                    // Add <access><returnType> as the key.
+                    methodSignatureLookupMap.add(accessFlagsReturnKey, methodClassPair)
+
+                    // Add <access><returnType>[parameters] as the key.
+                    methodSignatureLookupMap.add(
+                        buildString {
+                            append(accessFlagsReturnKey)
+                            appendParameters(method.parameterTypes)
+                        },
+                        methodClassPair
+                    )
+
+                    // Add strings contained in the method as the key.
+                    method.implementation?.instructions?.forEach instructions@{ instruction ->
+                        if (instruction.opcode != Opcode.CONST_STRING && instruction.opcode != Opcode.CONST_STRING_JUMBO)
+                            return@instructions
+
+                        val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+
+                        methodStringsLookupMap.add(string, methodClassPair)
+                    }
+
+                    // In the future, the class type could be added to the lookup map.
+                    // This would require MethodFingerprint to be changed to include the class type.
+                }
+            }
+        }
+
+        /**
+         * Clears the internal lookup maps created in [initializeFingerprintResolutionLookupMaps]
+         */
+        internal fun clearFingerprintResolutionLookupMaps() {
+            methods.clear()
+            methodSignatureLookupMap.clear()
+            methodStringsLookupMap.clear()
+        }
+
+        /**
+         * Resolve a list of [MethodFingerprint] using the lookup map built by [initializeFingerprintResolutionLookupMaps].
+         *
+         * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
+         * amount of time because they are resolved in sequence.
+         *
+         * For apps with many fingerprints, resolving performance can be improved by:
+         * - Slowest: Specify [opcodes] and nothing else.
+         * - Fast: Specify [accessFlags], [returnType].
+         * - Faster: Specify [accessFlags], [returnType] and [parameters].
+         * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
+         */
+        internal fun Iterable<MethodFingerprint>.resolveUsingLookupMap(context: BytecodeContext) {
+            if (methods.isEmpty()) throw PatchException("lookup map not initialized")
+
+            for (fingerprint in this) {
+                fingerprint.resolveUsingLookupMap(context)
+            }
+        }
+
+        /**
+         * Resolve a [MethodFingerprint] using the lookup map built by [initializeFingerprintResolutionLookupMaps].
+         *
+         * [MethodFingerprint] resolution is fast, but if many are present they can consume a noticeable
+         * amount of time because they are resolved in sequence.
+         *
+         * For apps with many fingerprints, resolving performance can be improved by:
+         * - Slowest: Specify [opcodes] and nothing else.
+         * - Fast: Specify [accessFlags], [returnType].
+         * - Faster: Specify [accessFlags], [returnType] and [parameters].
+         * - Fastest: Specify [strings], with at least one string being an exact (non-partial) match.
+         */
+        internal fun MethodFingerprint.resolveUsingLookupMap(context: BytecodeContext): Boolean {
+            /**
+             * Lookup [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
+             *
+             * @return A list of [MethodClassPair]s that match the methods strings present in a [MethodFingerprint].
+             */
+            fun MethodFingerprint.methodStringsLookup(): List<MethodClassPair>? {
+                strings?.forEach {
+                    val methods = methodStringsLookupMap[it]
+                    if (methods != null) return methods
+                }
+                return null
+            }
+
+            /**
+             * Lookup [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
+             *
+             * @return A list of [MethodClassPair]s that match the method signature present in a [MethodFingerprint].
+             */
+            fun MethodFingerprint.methodSignatureLookup(): List<MethodClassPair> {
+                if (accessFlags == null) return methods
+
+                var returnTypeValue = returnType
+                if (returnTypeValue == null) {
+                    if (AccessFlags.CONSTRUCTOR.isSet(accessFlags)) {
+                        // Constructors always have void return type
+                        returnTypeValue = "V"
+                    } else {
+                        return methods
+                    }
+                }
+
+                val key = buildString {
+                    append(accessFlags)
+                    append(returnTypeValue.first())
+                    if (parameters != null) appendParameters(parameters)
+                }
+                return methodSignatureLookupMap[key] ?: return emptyList()
+            }
+
+            /**
+             * Resolve a [MethodFingerprint] using a list of [MethodClassPair].
+             *
+             * @return True if the resolution was successful, false otherwise.
+             */
+            fun MethodFingerprint.resolveUsingMethodClassPair(classMethods: Iterable<MethodClassPair>): Boolean {
+                classMethods.forEach { classAndMethod ->
+                    if (resolve(context, classAndMethod.first, classAndMethod.second)) return true
+                }
+                return false
+            }
+
+            val methodsWithSameStrings = methodStringsLookup()
+            if (methodsWithSameStrings != null) if (resolveUsingMethodClassPair(methodsWithSameStrings)) return true
+
+            // No strings declared or none matched (partial matches are allowed).
+            // Use signature matching.
+            return resolveUsingMethodClassPair(methodSignatureLookup())
+        }
+
         /**
          * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
          *
@@ -48,10 +247,10 @@ abstract class MethodFingerprint(
          * @return True if the resolution was successful, false otherwise.
          */
         fun Iterable<MethodFingerprint>.resolve(context: BytecodeContext, classes: Iterable<ClassDef>) {
-            for (fingerprint in this) // For each fingerprint
+            for (fingerprint in this) // For each fingerprint...
-                classes@ for (classDef in classes) // search through all classes for the fingerprint
+                classes@ for (classDef in classes) // ...search through all classes for the MethodFingerprint
                     if (fingerprint.resolve(context, classDef))
-                        break@classes // if the resolution succeeded, continue with the next fingerprint
+                        break@classes // ...if the resolution succeeded, continue with the next MethodFingerprint.
         }
 
         /**
@@ -144,6 +343,52 @@ abstract class MethodFingerprint(
             val patternScanResult = if (methodFingerprint.opcodes != null) {
                 method.implementation?.instructions ?: return false
 
+                fun Method.patternScan(
+                    fingerprint: MethodFingerprint
+                ): MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult? {
+                    val instructions = this.implementation!!.instructions
+                    val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyPatternScanMethod?.threshold ?: 0
+
+                    val pattern = fingerprint.opcodes!!
+                    val instructionLength = instructions.count()
+                    val patternLength = pattern.count()
+
+                    for (index in 0 until instructionLength) {
+                        var patternIndex = 0
+                        var threshold = fingerprintFuzzyPatternScanThreshold
+
+                        while (index + patternIndex < instructionLength) {
+                            val originalOpcode = instructions.elementAt(index + patternIndex).opcode
+                            val patternOpcode = pattern.elementAt(patternIndex)
+
+                            if (patternOpcode != null && patternOpcode.ordinal != originalOpcode.ordinal) {
+                                // reaching maximum threshold (0) means,
+                                // the pattern does not match to the current instructions
+                                if (threshold-- == 0) break
+                            }
+
+                            if (patternIndex < patternLength - 1) {
+                                // if the entire pattern has not been scanned yet
+                                // continue the scan
+                                patternIndex++
+                                continue
+                            }
+                            // the pattern is valid, generate warnings if fuzzyPatternScanMethod is FuzzyPatternScanMethod
+                            val result =
+                                MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult(
+                                    index,
+                                    index + patternIndex
+                                )
+                            if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
+                            result.warnings = result.createWarnings(pattern, instructions)
+
+                            return result
+                        }
+                    }
+
+                    return null
+                }
+
                 method.patternScan(methodFingerprint) ?: return false
             } else null
 
@@ -160,52 +405,6 @@ abstract class MethodFingerprint(
             return true
         }
 
-        private fun Method.patternScan(
-            fingerprint: MethodFingerprint
-        ): MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult? {
-            val instructions = this.implementation!!.instructions
-            val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyPatternScanMethod?.threshold ?: 0
-
-            val pattern = fingerprint.opcodes!!
-            val instructionLength = instructions.count()
-            val patternLength = pattern.count()
-
-            for (index in 0 until instructionLength) {
-                var patternIndex = 0
-                var threshold = fingerprintFuzzyPatternScanThreshold
-
-                while (index + patternIndex < instructionLength) {
-                    val originalOpcode = instructions.elementAt(index + patternIndex).opcode
-                    val patternOpcode = pattern.elementAt(patternIndex)
-
-                    if (patternOpcode != null && patternOpcode.ordinal != originalOpcode.ordinal) {
-                        // reaching maximum threshold (0) means,
-                        // the pattern does not match to the current instructions
-                        if (threshold-- == 0) break
-                    }
-
-                    if (patternIndex < patternLength - 1) {
-                        // if the entire pattern has not been scanned yet
-                        // continue the scan
-                        patternIndex++
-                        continue
-                    }
-                    // the pattern is valid, generate warnings if fuzzyPatternScanMethod is FuzzyPatternScanMethod
-                    val result =
-                        MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult(
-                            index,
-                            index + patternIndex
-                        )
-                    if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
-                    result.warnings = result.createWarnings(pattern, instructions)
-
-                    return result
-                }
-            }
-
-            return null
-        }
-
         private fun MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.createWarnings(
             pattern: Iterable<Opcode?>, instructions: Iterable<Instruction>
         ) = buildList {
@@ -311,4 +510,4 @@ data class MethodFingerprintResult(
             )
         }
     }
-}
+}

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/patch/Patch.kt

@@ -6,20 +6,22 @@ import app.revanced.patcher.data.ResourceContext
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 import java.io.Closeable
 
+typealias PatchClass = Class<out Patch<Context<*>>>
+
 /**
  * A ReVanced patch.
  *
  * If it implements [Closeable], it will be closed after all patches have been executed.
  * Closing will be done in reverse execution order.
  */
-sealed interface Patch<out T : Context> {
+sealed interface Patch<out T : Context<*>> {
     /**
      * The main function of the [Patch] which the patcher will call.
      *
      * @param context The [Context] the patch will work on.
      * @return The result of executing the patch.
      */
-    fun execute(context: @UnsafeVariance T): PatchResult
+    fun execute(context: @UnsafeVariance T)
 }
 
 /**

src/main/kotlin/app/revanced/patcher/patch/PatchException.kt

@@ -0,0 +1,12 @@
+package app.revanced.patcher.patch
+
+/**
+ * An exception thrown when patching.
+ *
+ * @param errorMessage The exception message.
+ * @param cause The corresponding [Throwable].
+ */
+class PatchException(errorMessage: String?, cause: Throwable?) : Exception(errorMessage, cause) {
+    constructor(errorMessage: String) : this(errorMessage, null)
+    constructor(cause: Throwable) : this(cause.message, cause)
+}

src/main/kotlin/app/revanced/patcher/patch/PatchOption.kt

@@ -79,10 +79,10 @@ class PatchOptions(vararg options: PatchOption<*>) : Iterable<PatchOption<*>> {
 
 /**
  * A [Patch] option.
- * @param key Unique identifier of the option. Example: _`settings.microg.enabled`_
+ * @param key Unique identifier of the option. Example: _`settings`_
  * @param default The default value of the option.
- * @param title A human-readable title of the option. Example: _MicroG Settings_
+ * @param title A human-readable title of the option. Example: _Patch Settings_
- * @param description A human-readable description of the option. Example: _Settings integration for MicroG._
+ * @param description A human-readable description of the option. Example: _Settings for the patches._
  * @param required Whether the option is required.
  */
 @Suppress("MemberVisibilityCanBePrivate")
@@ -229,20 +229,4 @@ sealed class PatchOption<T>(
     ) : ListOption<Int>(
         key, default, options, title, description, required, validator
     )
-
-    /**
-     * A [PatchOption] representing a [Path], backed by a [String].
-     * The validator passes a [String], if you need a [Path] you will have to convert it yourself.
-     * @see PatchOption
-     */
-    class PathOption(
-        key: String,
-        default: Path?,
-        title: String,
-        description: String,
-        required: Boolean = false,
-        validator: (String?) -> Boolean = { true }
-    ) : PatchOption<String>(
-        key, default?.pathString, title, description, required, validator
-    )
 }

src/main/kotlin/app/revanced/patcher/patch/PatchResult.kt

@@ -1,35 +1,10 @@
 package app.revanced.patcher.patch
 
-interface PatchResult {
+/**
-    fun error(): PatchResultError? {
+ * A result of executing a [Patch].
-        if (this is PatchResultError) {
+ *
-            return this
+ * @param patchName The name of the [Patch].
-        }
+ * @param exception The [PatchException] thrown, if any.
-        return null
+ */
-    }
+@Suppress("MemberVisibilityCanBePrivate")
-
+class PatchResult internal constructor(val patchName: String, val exception: PatchException? = null)
-    fun success(): PatchResultSuccess? {
-        if (this is PatchResultSuccess) {
-            return this
-        }
-        return null
-    }
-
-    fun isError(): Boolean {
-        return this is PatchResultError
-    }
-
-    fun isSuccess(): Boolean {
-        return this is PatchResultSuccess
-    }
-}
-
-class PatchResultError(
-    errorMessage: String?, cause: Exception?
-) : Exception(errorMessage, cause), PatchResult {
-    constructor(errorMessage: String) : this(errorMessage, null)
-    constructor(cause: Exception) : this(cause.message, cause)
-
-}
-
-class PatchResultSuccess : PatchResult

src/main/kotlin/app/revanced/patcher/patch/annotations/PatchAnnotation.kt

@@ -16,12 +16,12 @@ annotation class Patch(val include: Boolean = true)
  */
 @Target(AnnotationTarget.CLASS)
 annotation class DependsOn(
-    val dependencies: Array<KClass<out Patch<Context>>> = []
+    val dependencies: Array<KClass<out Patch<Context<*>>>> = []
 )
 
-
+// TODO: Remove this annotation, once integrations are coupled with patches.
 /**
  * Annotation to mark [Patch]es which depend on integrations.
  */
 @Target(AnnotationTarget.CLASS)
-annotation class RequiresIntegrations // required because integrations are decoupled from patches
+annotation class RequiresIntegrations

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

@@ -1,23 +1,23 @@
 package app.revanced.patcher.util
 
-import app.revanced.patcher.PatcherContext
+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
 import app.revanced.patcher.util.ClassMerger.Utils.isPublic
 import app.revanced.patcher.util.ClassMerger.Utils.toPublic
-import app.revanced.patcher.util.TypeUtil.traverseClassHierarchy
+import app.revanced.patcher.util.ClassMerger.Utils.traverseClassHierarchy
 import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
 import app.revanced.patcher.util.proxy.mutableTypes.MutableClass.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableField
 import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import org.jf.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.AccessFlags
-import org.jf.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.ClassDef
-import org.jf.dexlib2.util.MethodUtil
+import com.android.tools.smali.dexlib2.util.MethodUtil
+import java.util.logging.Logger
 import kotlin.reflect.KFunction2
 
 /**
@@ -25,27 +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: PatcherContext, logger: Logger? = null) = this
+    fun ClassDef.merge(otherClass: ClassDef, context: BytecodeContext) = this
-        //.fixFieldAccess(otherClass, logger)
+        //.fixFieldAccess(otherClass)
-        //.fixMethodAccess(otherClass, logger)
+        //.fixMethodAccess(otherClass)
-        .addMissingFields(otherClass, logger)
+        .addMissingFields(otherClass)
-        .addMissingMethods(otherClass, logger)
+        .addMissingMethods(otherClass)
-        .publicize(otherClass, context, logger)
+        .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 ->
@@ -56,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() })
@@ -67,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() })
@@ -87,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: PatcherContext, logger: Logger? = null) =
+    private fun ClassDef.publicize(reference: ClassDef, context: BytecodeContext) =
         if (reference.accessFlags.isPublic() && !accessFlags.isPublic())
             this.asMutableClass().apply {
-                context.bytecodeContext.traverseClassHierarchy(this) {
+                context.traverseClassHierarchy(this) {
                     if (accessFlags.isPublic()) return@traverseClassHierarchy
 
-                    logger?.trace("Publicizing ${this.type}")
+                    logger.fine("Publicizing ${this.type}")
 
                     accessFlags = accessFlags.toPublic()
                 }
@@ -106,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
 
@@ -117,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.
@@ -135,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
 
@@ -146,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.
@@ -161,6 +158,19 @@ internal object ClassMerger {
     }
 
     private object Utils {
+        /**
+         * traverse the class hierarchy starting from the given root class
+         *
+         * @param targetClass the class to start traversing the class hierarchy from
+         * @param callback function that is called for every class in the hierarchy
+         */
+        fun BytecodeContext.traverseClassHierarchy(targetClass: MutableClass, callback: MutableClass.() -> Unit) {
+            callback(targetClass)
+            this.findClass(targetClass.superclass ?: return)?.mutableClass?.let {
+                traverseClassHierarchy(it, callback)
+            }
+        }
+
         fun ClassDef.asMutableClass() = if (this is MutableClass) this else this.toMutable()
 
         /**
@@ -180,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].
@@ -192,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/main/kotlin/app/revanced/patcher/util/DomFileEditor.kt

@@ -0,0 +1,87 @@
+package app.revanced.patcher.util
+
+import org.w3c.dom.Document
+import java.io.Closeable
+import java.io.File
+import java.io.InputStream
+import java.io.OutputStream
+import javax.xml.parsers.DocumentBuilderFactory
+import javax.xml.transform.TransformerFactory
+import javax.xml.transform.dom.DOMSource
+import javax.xml.transform.stream.StreamResult
+
+/**
+ * Wrapper for a file that can be edited as a dom document.
+ *
+ * This constructor does not check for locks to the file when writing.
+ * Use the secondary constructor.
+ *
+ * @param inputStream the input stream to read the xml file from.
+ * @param outputStream the output stream to write the xml file to. If null, the file will be read only.
+ *
+ */
+class DomFileEditor internal constructor(
+    private val inputStream: InputStream,
+    private val outputStream: Lazy<OutputStream>? = null,
+) : Closeable {
+    // path to the xml file to unlock the resource when closing the editor
+    private var filePath: String? = null
+    private var closed: Boolean = false
+
+    /**
+     * The document of the xml file
+     */
+    val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream)
+        .also(Document::normalize)
+
+
+    // lazily open an output stream
+    // this is required because when constructing a DomFileEditor the output stream is created along with the input stream, which is not allowed
+    // the workaround is to lazily create the output stream. This way it would be used after the input stream is closed, which happens in the constructor
+    constructor(file: File) : this(file.inputStream(), lazy { file.outputStream() }) {
+        // increase the lock
+        locks.merge(file.path, 1, Integer::sum)
+        filePath = file.path
+    }
+
+    /**
+     * Closes the editor. Write backs and decreases the lock count.
+     *
+     * Will not write back to the file if the file is still locked.
+     */
+    override fun close() {
+        if (closed) return
+
+        inputStream.close()
+
+        // if the output stream is not null, do not close it
+        outputStream?.let {
+            // prevent writing to same file, if it is being locked
+            // isLocked will be false if the editor was created through a stream
+            val isLocked = filePath?.let { path ->
+                val isLocked = locks[path]!! > 1
+                // decrease the lock count if the editor was opened for a file
+                locks.merge(path, -1, Integer::sum)
+                isLocked
+            } ?: false
+
+            // if unlocked, write back to the file
+            if (!isLocked) {
+                it.value.use { stream ->
+                    val result = StreamResult(stream)
+                    TransformerFactory.newInstance().newTransformer().transform(DOMSource(file), result)
+                }
+
+                it.value.close()
+                return
+            }
+        }
+
+        closed = true
+    }
+
+    private companion object {
+        // map of concurrent open files
+        val locks = mutableMapOf<String, Int>()
+    }
+}

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

@@ -1,15 +0,0 @@
-package app.revanced.patcher.util
-
-internal class ListBackedSet<E>(private val list: MutableList<E>) : MutableSet<E> {
-    override val size get() = list.size
-    override fun add(element: E) = list.add(element)
-    override fun addAll(elements: Collection<E>) = list.addAll(elements)
-    override fun clear() = list.clear()
-    override fun iterator() = list.listIterator()
-    override fun remove(element: E) = list.remove(element)
-    override fun removeAll(elements: Collection<E>) = list.removeAll(elements)
-    override fun retainAll(elements: Collection<E>) = list.retainAll(elements)
-    override fun contains(element: E) = list.contains(element)
-    override fun containsAll(elements: Collection<E>) = list.containsAll(elements)
-    override fun isEmpty() = list.isEmpty()
-}

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

@@ -1,46 +0,0 @@
-package app.revanced.patcher.util
-
-import app.revanced.patcher.util.proxy.ClassProxy
-import org.jf.dexlib2.iface.ClassDef
-
-/**
- * A class that represents a set of classes and proxies.
- *
- * @param classes The classes to be backed by proxies.
- */
-class ProxyBackedClassList(internal val classes: MutableList<ClassDef>) : Set<ClassDef> {
-    internal val proxies = mutableListOf<ClassProxy>()
-
-    /**
-     * Add a [ClassDef].
-     */
-    fun add(classDef: ClassDef) = classes.add(classDef)
-
-    /**
-     * Add a [ClassProxy].
-     */
-    fun add(classProxy: ClassProxy) = proxies.add(classProxy)
-
-    /**
-     * Replace all classes with their mutated versions.
-     */
-    internal fun replaceClasses() =
-        proxies.removeIf { proxy ->
-            // if the proxy is unused, keep it in the list
-            if (!proxy.resolved) return@removeIf false
-
-            // if it has been used, replace the original class with the new class
-            val index = classes.indexOfFirst { it.type == proxy.immutableClass.type }
-            classes[index] = proxy.mutableClass
-
-            // return true to remove it from the proxies list
-            return@removeIf true
-        }
-
-
-    override val size get() = classes.size
-    override fun contains(element: ClassDef) = classes.contains(element)
-    override fun containsAll(elements: Collection<ClassDef>) = classes.containsAll(elements)
-    override fun isEmpty() = classes.isEmpty()
-    override fun iterator() = classes.iterator()
-}

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

@@ -0,0 +1,33 @@
+package app.revanced.patcher.util
+
+import app.revanced.patcher.util.proxy.ClassProxy
+import com.android.tools.smali.dexlib2.iface.ClassDef
+
+/**
+ * A class that represents a set of classes and proxies.
+ *
+ * @param classes The classes to be backed by proxies.
+ */
+class ProxyClassList internal constructor(classes: MutableSet<ClassDef>) : MutableSet<ClassDef> by classes {
+    internal val proxies = mutableListOf<ClassProxy>()
+
+    /**
+     * Add a [ClassProxy].
+     */
+    fun add(classProxy: ClassProxy) = proxies.add(classProxy)
+
+    /**
+     * Replace all classes with their mutated versions.
+     */
+    internal fun replaceClasses() = proxies.removeIf { proxy ->
+        // If the proxy is unused, return false to keep it in the proxies list.
+            if (!proxy.resolved) return@removeIf false
+
+        // If it has been used, replace the original class with the mutable class.
+        remove(proxy.immutableClass)
+        add(proxy.mutableClass)
+
+        // Return true to remove the proxy from the proxies list.
+            return@removeIf true
+        }
+}

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

@@ -1,19 +0,0 @@
-package app.revanced.patcher.util
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
-
-object TypeUtil {
-    /**
-     * traverse the class hierarchy starting from the given root class
-     *
-     * @param targetClass the class to start traversing the class hierarchy from
-     * @param callback function that is called for every class in the hierarchy
-     */
-    fun BytecodeContext.traverseClassHierarchy(targetClass: MutableClass, callback: MutableClass.() -> Unit) {
-        callback(targetClass)
-        this.findClass(targetClass.superclass ?: return)?.mutableClass?.let {
-            traverseClassHierarchy(it, callback)
-        }
-    }
-}

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

@@ -1,18 +0,0 @@
-package app.revanced.patcher.util
-
-import java.util.*
-
-internal object VersionReader {
-    @JvmStatic
-    private val props = Properties().apply {
-        load(
-            VersionReader::class.java.getResourceAsStream("/revanced-patcher/version.properties")
-                ?: throw IllegalStateException("Could not load version.properties")
-        )
-    }
-
-    @JvmStatic
-    fun read(): String {
-        return props.getProperty("version") ?: throw IllegalStateException("Version not found")
-    }
-}

src/main/kotlin/app/revanced/patcher/util/dex/DexFile.kt

@@ -1,10 +0,0 @@
-package app.revanced.patcher.util.dex
-
-import java.io.InputStream
-
-/**
- * Wrapper for dex files.
- * @param name The original name of the dex file.
- * @param stream The dex file as [InputStream].
- */
-data class DexFile(val name: String, val stream: InputStream)

src/main/kotlin/app/revanced/patcher/util/method/MethodWalker.kt

@@ -2,10 +2,10 @@ package app.revanced.patcher.util.method
 
 import app.revanced.patcher.data.BytecodeContext
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import org.jf.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.Method
-import org.jf.dexlib2.iface.instruction.ReferenceInstruction
+import com.android.tools.smali.dexlib2.iface.instruction.ReferenceInstruction
-import org.jf.dexlib2.iface.reference.MethodReference
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
-import org.jf.dexlib2.util.MethodUtil
+import com.android.tools.smali.dexlib2.util.MethodUtil
 
 /**
  * Find a method from another method via instruction offsets.

src/main/kotlin/app/revanced/patcher/util/patch/PatchBundle.kt

@@ -1,70 +0,0 @@
-@file:Suppress("unused")
-
-package app.revanced.patcher.util.patch
-
-import app.revanced.patcher.data.Context
-import app.revanced.patcher.extensions.PatchExtensions.patchName
-import app.revanced.patcher.patch.Patch
-import org.jf.dexlib2.DexFileFactory
-import java.io.File
-import java.net.URLClassLoader
-import java.util.jar.JarFile
-
-/**
- * A patch bundle.
-
- * @param path The path to the patch bundle.
- */
-sealed class PatchBundle(path: String) : File(path) {
-    internal fun loadPatches(classLoader: ClassLoader, classNames: Iterator<String>) = buildList {
-        classNames.forEach { className ->
-            val clazz = classLoader.loadClass(className)
-            if (!clazz.isAnnotationPresent(app.revanced.patcher.patch.annotations.Patch::class.java)) return@forEach
-            @Suppress("UNCHECKED_CAST") this.add(clazz as Class<out Patch<Context>>)
-        }
-    }.sortedBy { it.patchName }
-
-    /**
-     * A patch bundle of type [Jar].
-     *
-     * @param patchBundlePath The path to the patch bundle.
-     */
-    class Jar(patchBundlePath: String) : PatchBundle(patchBundlePath) {
-
-        /**
-         * Load patches from the patch bundle.
-         *
-         * Patches will be loaded with a new [URLClassLoader].
-         */
-        fun loadPatches() = loadPatches(
-            URLClassLoader(
-                arrayOf(this.toURI().toURL()),
-                Thread.currentThread().contextClassLoader // TODO: find out why this is required
-            ),
-            JarFile(this)
-                .stream()
-                .filter {it.name.endsWith(".class") && !it.name.contains("$")}
-                .map({it -> it.realName.replace('/', '.').replace(".class", "")}).iterator()
-            )
-                    
-        
-    }
-
-    /**
-     * A patch bundle of type [Dex] format.
-     *
-     * @param patchBundlePath The path to a patch bundle of dex format.
-     * @param dexClassLoader The dex class loader.
-     */
-    class Dex(patchBundlePath: String, private val dexClassLoader: ClassLoader) : PatchBundle(patchBundlePath) {
-        /**
-         * Load patches from the patch bundle.
-         *
-         * Patches will be loaded to the provided [dexClassLoader].
-         */
-        fun loadPatches() = loadPatches(dexClassLoader,
-            DexFileFactory.loadDexFile(path, null).classes.asSequence().map({ classDef ->
-                classDef.type.substring(1, classDef.length - 1).replace('/', '.')
-            }).iterator())
-    }
-}

src/main/kotlin/app/revanced/patcher/util/proxy/ClassProxy.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy
 
 import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
-import org.jf.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.ClassDef
 
 /**
  * A proxy class for a [ClassDef].

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotation.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher.util.proxy.mutableTypes
 
 import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
-import org.jf.dexlib2.base.BaseAnnotation
+import com.android.tools.smali.dexlib2.base.BaseAnnotation
-import org.jf.dexlib2.iface.Annotation
+import com.android.tools.smali.dexlib2.iface.Annotation
 
 class MutableAnnotation(annotation: Annotation) : BaseAnnotation() {
     private val visibility = annotation.visibility

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement.kt

@@ -2,9 +2,9 @@ package app.revanced.patcher.util.proxy.mutableTypes
 
 import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue
 import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
-import org.jf.dexlib2.base.BaseAnnotationElement
+import com.android.tools.smali.dexlib2.base.BaseAnnotationElement
-import org.jf.dexlib2.iface.AnnotationElement
+import com.android.tools.smali.dexlib2.iface.AnnotationElement
-import org.jf.dexlib2.iface.value.EncodedValue
+import com.android.tools.smali.dexlib2.iface.value.EncodedValue
 
 class MutableAnnotationElement(annotationElement: AnnotationElement) : BaseAnnotationElement() {
     private var name = annotationElement.name

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableClass.kt

@@ -4,10 +4,10 @@ import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.
 import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
 import com.google.common.collect.Iterables
-import org.jf.dexlib2.base.reference.BaseTypeReference
+import com.android.tools.smali.dexlib2.base.reference.BaseTypeReference
-import org.jf.dexlib2.iface.ClassDef
+import com.android.tools.smali.dexlib2.iface.ClassDef
-import org.jf.dexlib2.util.FieldUtil
+import com.android.tools.smali.dexlib2.util.FieldUtil
-import org.jf.dexlib2.util.MethodUtil
+import com.android.tools.smali.dexlib2.util.MethodUtil
 
 class MutableClass(classDef: ClassDef) : ClassDef, BaseTypeReference() {
     // Class

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableField.kt

@@ -3,9 +3,9 @@ package app.revanced.patcher.util.proxy.mutableTypes
 import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue
 import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
-import org.jf.dexlib2.HiddenApiRestriction
+import com.android.tools.smali.dexlib2.HiddenApiRestriction
-import org.jf.dexlib2.base.reference.BaseFieldReference
+import com.android.tools.smali.dexlib2.base.reference.BaseFieldReference
-import org.jf.dexlib2.iface.Field
+import com.android.tools.smali.dexlib2.iface.Field
 
 class MutableField(field: Field) : Field, BaseFieldReference() {
     private var definingClass = field.definingClass

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableMethod.kt

@@ -2,10 +2,10 @@ package app.revanced.patcher.util.proxy.mutableTypes
 
 import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethodParameter.Companion.toMutable
-import org.jf.dexlib2.HiddenApiRestriction
+import com.android.tools.smali.dexlib2.HiddenApiRestriction
-import org.jf.dexlib2.base.reference.BaseMethodReference
+import com.android.tools.smali.dexlib2.base.reference.BaseMethodReference
-import org.jf.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
-import org.jf.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.iface.Method
 
 class MutableMethod(method: Method) : Method, BaseMethodReference() {
     private var definingClass = method.definingClass

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableMethodParameter.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher.util.proxy.mutableTypes
 
 import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
-import org.jf.dexlib2.base.BaseMethodParameter
+import com.android.tools.smali.dexlib2.base.BaseMethodParameter
-import org.jf.dexlib2.iface.MethodParameter
+import com.android.tools.smali.dexlib2.iface.MethodParameter
 
 // TODO: finish overriding all members if necessary
 class MutableMethodParameter(parameter: MethodParameter) : MethodParameter, BaseMethodParameter() {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue.kt

@@ -1,9 +1,9 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
 import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
-import org.jf.dexlib2.base.value.BaseAnnotationEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseAnnotationEncodedValue
-import org.jf.dexlib2.iface.AnnotationElement
+import com.android.tools.smali.dexlib2.iface.AnnotationElement
-import org.jf.dexlib2.iface.value.AnnotationEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.AnnotationEncodedValue
 
 class MutableAnnotationEncodedValue(annotationEncodedValue: AnnotationEncodedValue) : BaseAnnotationEncodedValue(),
     MutableEncodedValue {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableArrayEncodedValue.kt

@@ -1,9 +1,9 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
 import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
-import org.jf.dexlib2.base.value.BaseArrayEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseArrayEncodedValue
-import org.jf.dexlib2.iface.value.ArrayEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.ArrayEncodedValue
-import org.jf.dexlib2.iface.value.EncodedValue
+import com.android.tools.smali.dexlib2.iface.value.EncodedValue
 
 class MutableArrayEncodedValue(arrayEncodedValue: ArrayEncodedValue) : BaseArrayEncodedValue(), MutableEncodedValue {
     private val _value by lazy {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseBooleanEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseBooleanEncodedValue
-import org.jf.dexlib2.iface.value.BooleanEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.BooleanEncodedValue
 
 class MutableBooleanEncodedValue(booleanEncodedValue: BooleanEncodedValue) : BaseBooleanEncodedValue(),
     MutableEncodedValue {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseByteEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseByteEncodedValue
-import org.jf.dexlib2.iface.value.ByteEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.ByteEncodedValue
 
 class MutableByteEncodedValue(byteEncodedValue: ByteEncodedValue) : BaseByteEncodedValue(), MutableEncodedValue {
     private var value = byteEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableCharEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseCharEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseCharEncodedValue
-import org.jf.dexlib2.iface.value.CharEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.CharEncodedValue
 
 class MutableCharEncodedValue(charEncodedValue: CharEncodedValue) : BaseCharEncodedValue(), MutableEncodedValue {
     private var value = charEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseDoubleEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseDoubleEncodedValue
-import org.jf.dexlib2.iface.value.DoubleEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.DoubleEncodedValue
 
 class MutableDoubleEncodedValue(doubleEncodedValue: DoubleEncodedValue) : BaseDoubleEncodedValue(),
     MutableEncodedValue {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.ValueType
+import com.android.tools.smali.dexlib2.ValueType
-import org.jf.dexlib2.iface.value.*
+import com.android.tools.smali.dexlib2.iface.value.*
 
 interface MutableEncodedValue : EncodedValue {
     companion object {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEnumEncodedValue.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseEnumEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseEnumEncodedValue
-import org.jf.dexlib2.iface.reference.FieldReference
+import com.android.tools.smali.dexlib2.iface.reference.FieldReference
-import org.jf.dexlib2.iface.value.EnumEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.EnumEncodedValue
 
 class MutableEnumEncodedValue(enumEncodedValue: EnumEncodedValue) : BaseEnumEncodedValue(), MutableEncodedValue {
     private var value = enumEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFieldEncodedValue.kt

@@ -1,9 +1,9 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.ValueType
+import com.android.tools.smali.dexlib2.ValueType
-import org.jf.dexlib2.base.value.BaseFieldEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseFieldEncodedValue
-import org.jf.dexlib2.iface.reference.FieldReference
+import com.android.tools.smali.dexlib2.iface.reference.FieldReference
-import org.jf.dexlib2.iface.value.FieldEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.FieldEncodedValue
 
 class MutableFieldEncodedValue(fieldEncodedValue: FieldEncodedValue) : BaseFieldEncodedValue(), MutableEncodedValue {
     private var value = fieldEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseFloatEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseFloatEncodedValue
-import org.jf.dexlib2.iface.value.FloatEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.FloatEncodedValue
 
 class MutableFloatEncodedValue(floatEncodedValue: FloatEncodedValue) : BaseFloatEncodedValue(), MutableEncodedValue {
     private var value = floatEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseIntEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseIntEncodedValue
-import org.jf.dexlib2.iface.value.IntEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.IntEncodedValue
 
 class MutableIntEncodedValue(intEncodedValue: IntEncodedValue) : BaseIntEncodedValue(), MutableEncodedValue {
     private var value = intEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableLongEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseLongEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseLongEncodedValue
-import org.jf.dexlib2.iface.value.LongEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.LongEncodedValue
 
 class MutableLongEncodedValue(longEncodedValue: LongEncodedValue) : BaseLongEncodedValue(), MutableEncodedValue {
     private var value = longEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseMethodEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseMethodEncodedValue
-import org.jf.dexlib2.iface.reference.MethodReference
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
-import org.jf.dexlib2.iface.value.MethodEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.MethodEncodedValue
 
 class MutableMethodEncodedValue(methodEncodedValue: MethodEncodedValue) : BaseMethodEncodedValue(),
     MutableEncodedValue {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseMethodHandleEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseMethodHandleEncodedValue
-import org.jf.dexlib2.iface.reference.MethodHandleReference
+import com.android.tools.smali.dexlib2.iface.reference.MethodHandleReference
-import org.jf.dexlib2.iface.value.MethodHandleEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.MethodHandleEncodedValue
 
 class MutableMethodHandleEncodedValue(methodHandleEncodedValue: MethodHandleEncodedValue) :
     BaseMethodHandleEncodedValue(),

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseMethodTypeEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseMethodTypeEncodedValue
-import org.jf.dexlib2.iface.reference.MethodProtoReference
+import com.android.tools.smali.dexlib2.iface.reference.MethodProtoReference
-import org.jf.dexlib2.iface.value.MethodTypeEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.MethodTypeEncodedValue
 
 class MutableMethodTypeEncodedValue(methodTypeEncodedValue: MethodTypeEncodedValue) : BaseMethodTypeEncodedValue(),
     MutableEncodedValue {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableNullEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseNullEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseNullEncodedValue
-import org.jf.dexlib2.iface.value.ByteEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.ByteEncodedValue
 
 class MutableNullEncodedValue : BaseNullEncodedValue(), MutableEncodedValue {
     companion object {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableShortEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseShortEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseShortEncodedValue
-import org.jf.dexlib2.iface.value.ShortEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.ShortEncodedValue
 
 class MutableShortEncodedValue(shortEncodedValue: ShortEncodedValue) : BaseShortEncodedValue(), MutableEncodedValue {
     private var value = shortEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableStringEncodedValue.kt

@@ -1,8 +1,8 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseStringEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseStringEncodedValue
-import org.jf.dexlib2.iface.value.ByteEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.ByteEncodedValue
-import org.jf.dexlib2.iface.value.StringEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.StringEncodedValue
 
 class MutableStringEncodedValue(stringEncodedValue: StringEncodedValue) : BaseStringEncodedValue(),
     MutableEncodedValue {

src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableTypeEncodedValue.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
 
-import org.jf.dexlib2.base.value.BaseTypeEncodedValue
+import com.android.tools.smali.dexlib2.base.value.BaseTypeEncodedValue
-import org.jf.dexlib2.iface.value.TypeEncodedValue
+import com.android.tools.smali.dexlib2.iface.value.TypeEncodedValue
 
 class MutableTypeEncodedValue(typeEncodedValue: TypeEncodedValue) : BaseTypeEncodedValue(), MutableEncodedValue {
     private var value = typeEncodedValue.value

src/main/kotlin/app/revanced/patcher/util/smali/ExternalLabel.kt

@@ -1,6 +1,6 @@
 package app.revanced.patcher.util.smali
 
-import org.jf.dexlib2.iface.instruction.Instruction
+import com.android.tools.smali.dexlib2.iface.instruction.Instruction
 
 /**
  * A class that represents a label for an instruction.

src/main/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompiler.kt

@@ -4,14 +4,14 @@ import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
 import org.antlr.runtime.CommonTokenStream
 import org.antlr.runtime.TokenSource
 import org.antlr.runtime.tree.CommonTreeNodeStream
-import org.jf.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.AccessFlags
-import org.jf.dexlib2.Opcodes
+import com.android.tools.smali.dexlib2.Opcodes
-import org.jf.dexlib2.builder.BuilderInstruction
+import com.android.tools.smali.dexlib2.builder.BuilderInstruction
-import org.jf.dexlib2.writer.builder.DexBuilder
+import com.android.tools.smali.dexlib2.writer.builder.DexBuilder
-import org.jf.smali.LexerErrorInterface
+import com.android.tools.smali.smali.LexerErrorInterface
-import org.jf.smali.smaliFlexLexer
+import com.android.tools.smali.smali.smaliFlexLexer
-import org.jf.smali.smaliParser
+import com.android.tools.smali.smali.smaliParser
-import org.jf.smali.smaliTreeWalker
+import com.android.tools.smali.smali.smaliTreeWalker
 import java.io.InputStreamReader
 
 private const val METHOD_TEMPLATE = """

src/test/kotlin/app/revanced/patcher/extensions/InstructionExtensionsTest.kt

@@ -11,13 +11,13 @@ import app.revanced.patcher.extensions.InstructionExtensions.replaceInstructions
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
 import app.revanced.patcher.util.smali.ExternalLabel
-import org.jf.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.AccessFlags
-import org.jf.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.Opcode
-import org.jf.dexlib2.builder.BuilderOffsetInstruction
+import com.android.tools.smali.dexlib2.builder.BuilderOffsetInstruction
-import org.jf.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
-import org.jf.dexlib2.builder.instruction.BuilderInstruction21s
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21s
-import org.jf.dexlib2.iface.instruction.OneRegisterInstruction
+import com.android.tools.smali.dexlib2.iface.instruction.OneRegisterInstruction
-import org.jf.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import kotlin.test.assertEquals

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

@@ -3,8 +3,6 @@ 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.io.path.Path
-import kotlin.io.path.pathString
 import kotlin.test.assertNotEquals
 
 internal class PatchOptionsTest {
@@ -35,10 +33,6 @@ internal class PatchOptionsTest {
                         println(choice)
                     }
                 }
-
-                is PatchOption.PathOption -> {
-                    option.value = Path("test.txt").pathString
-                }
             }
         }
         val option = options.get<String>("key1")

src/test/kotlin/app/revanced/patcher/usage/bytecode/ExampleBytecodePatch.kt

@@ -2,45 +2,44 @@ package app.revanced.patcher.usage.bytecode
 
 import app.revanced.patcher.annotation.Description
 import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.annotation.Version
 import app.revanced.patcher.data.BytecodeContext
 import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
-import app.revanced.patcher.extensions.or
 import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
-import app.revanced.patcher.patch.*
+import app.revanced.patcher.extensions.or
+import app.revanced.patcher.patch.BytecodePatch
+import app.revanced.patcher.patch.OptionsContainer
+import app.revanced.patcher.patch.PatchOption
 import app.revanced.patcher.patch.annotations.DependsOn
 import app.revanced.patcher.patch.annotations.Patch
 import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
 import app.revanced.patcher.usage.resource.patch.ExampleResourcePatch
 import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.Format
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction11x
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21c
+import com.android.tools.smali.dexlib2.iface.instruction.formats.Instruction21c
+import com.android.tools.smali.dexlib2.immutable.ImmutableField
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethodImplementation
+import com.android.tools.smali.dexlib2.immutable.reference.ImmutableFieldReference
+import com.android.tools.smali.dexlib2.immutable.reference.ImmutableStringReference
+import com.android.tools.smali.dexlib2.immutable.value.ImmutableFieldEncodedValue
+import com.android.tools.smali.dexlib2.util.Preconditions
 import com.google.common.collect.ImmutableList
-import org.jf.dexlib2.AccessFlags
-import org.jf.dexlib2.Format
-import org.jf.dexlib2.Opcode
-import org.jf.dexlib2.builder.MutableMethodImplementation
-import org.jf.dexlib2.builder.instruction.BuilderInstruction11x
-import org.jf.dexlib2.builder.instruction.BuilderInstruction21c
-import org.jf.dexlib2.iface.instruction.formats.Instruction21c
-import org.jf.dexlib2.immutable.ImmutableField
-import org.jf.dexlib2.immutable.ImmutableMethod
-import org.jf.dexlib2.immutable.ImmutableMethodImplementation
-import org.jf.dexlib2.immutable.reference.ImmutableFieldReference
-import org.jf.dexlib2.immutable.reference.ImmutableStringReference
-import org.jf.dexlib2.immutable.value.ImmutableFieldEncodedValue
-import org.jf.dexlib2.util.Preconditions
-import kotlin.io.path.Path
 
 @Patch
 @Name("example-bytecode-patch")
 @Description("Example demonstration of a bytecode patch.")
 @ExampleResourceCompatibility
-@Version("0.0.1")
 @DependsOn([ExampleResourcePatch::class])
 class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
     // This function will be executed by the patcher.
     // You can treat it as a constructor
-    override fun execute(context: BytecodeContext): PatchResult {
+    override fun execute(context: BytecodeContext) {
         // Get the resolved method by its fingerprint from the resolver cache
         val result = ExampleFingerprint.result!!
 
@@ -127,12 +126,6 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
                 invoke-virtual { v0, v1 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
                 """
         )
-
-        // Finally, tell the patcher that this patch was a success.
-        // You can also return PatchResultError with a message.
-        // If an exception is thrown inside this function,
-        // a PatchResultError will be returned with the error message.
-        return PatchResultSuccess()
     }
 
     /**
@@ -193,10 +186,5 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
                 "key5", null, "title", "description", true
             )
         )
-        private var key6 by option(
-            PatchOption.PathOption(
-                "key6", Path("test.txt"), "title", "description", true
-            )
-        )
     }
 }

src/test/kotlin/app/revanced/patcher/usage/bytecode/ExampleFingerprint.kt

@@ -2,8 +2,8 @@ package app.revanced.patcher.usage.bytecode
 import app.revanced.patcher.extensions.or
 import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import org.jf.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.AccessFlags
-import org.jf.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.Opcode
 
 @FuzzyPatternScanMethod(2)
 object ExampleFingerprint : MethodFingerprint(

src/test/kotlin/app/revanced/patcher/usage/resource/patch/ExampleResourcePatch.kt

@@ -2,10 +2,7 @@ package app.revanced.patcher.usage.resource.patch
 
 import app.revanced.patcher.annotation.Description
 import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.annotation.Version
 import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.PatchResult
-import app.revanced.patcher.patch.PatchResultSuccess
 import app.revanced.patcher.patch.ResourcePatch
 import app.revanced.patcher.patch.annotations.Patch
 import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
@@ -15,9 +12,8 @@ import org.w3c.dom.Element
 @Name("example-resource-patch")
 @Description("Example demonstration of a resource patch.")
 @ExampleResourceCompatibility
-@Version("0.0.1")
 class ExampleResourcePatch : ResourcePatch {
-    override fun execute(context: ResourceContext): PatchResult {
+    override fun execute(context: ResourceContext) {
         context.xmlEditor["AndroidManifest.xml"].use { editor ->
             val element = editor // regular DomFileEditor
                 .file
@@ -29,7 +25,5 @@ class ExampleResourcePatch : ResourcePatch {
                     "exampleValue"
                 )
         }
-
-        return PatchResultSuccess()
     }
 }

src/test/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompilerTest.kt

@@ -5,14 +5,14 @@ import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWith
 import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
 import app.revanced.patcher.extensions.newLabel
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import org.jf.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.AccessFlags
-import org.jf.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.Opcode
-import org.jf.dexlib2.builder.BuilderInstruction
+import com.android.tools.smali.dexlib2.builder.BuilderInstruction
-import org.jf.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
-import org.jf.dexlib2.builder.instruction.BuilderInstruction21c
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21c
-import org.jf.dexlib2.builder.instruction.BuilderInstruction21t
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction21t
-import org.jf.dexlib2.immutable.ImmutableMethod
+import com.android.tools.smali.dexlib2.immutable.ImmutableMethod
-import org.jf.dexlib2.immutable.reference.ImmutableStringReference
+import com.android.tools.smali.dexlib2.immutable.reference.ImmutableStringReference
 import java.util.*
 import kotlin.test.Test
 import kotlin.test.assertEquals