chore(release): 1.0.0-dev.18 [skip ci]

# [1.0.0-dev.18](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.17...v1.0.0-dev.18) (2022-06-04)

### Features

* `Dependencies` annotation ([83d608a](83d608ac06))
* optional `forStaticMethod` parameter for `InlineSmaliCompiler.compileMethodInstructions` ([28b9847](28b98478e4))

.github/workflows/release.yml

@@ -1,5 +1,6 @@
 name: Release
 on:
+  workflow_dispatch:
   push:
     branches:
       - main

CHANGELOG.md

@@ -1,3 +1,59 @@
+# [1.0.0-dev.18](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.17...v1.0.0-dev.18) (2022-06-04)
+
+
+### Features
+
+* `Dependencies` annotation ([83d608a](https://github.com/revanced/revanced-patcher/commit/83d608ac06a7d5ceb31b6e0022b501d99edb63a3))
+* optional `forStaticMethod` parameter for `InlineSmaliCompiler.compileMethodInstructions` ([28b9847](https://github.com/revanced/revanced-patcher/commit/28b98478e4e8e8f238e82f7fa2307aeb1547955d))
+
+# [1.0.0-dev.17](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.16...v1.0.0-dev.17) (2022-05-31)
+
+
+### Features
+
+* patch dependencies annotation and `PatcherOptions` ([8442991](https://github.com/revanced/revanced-patcher/commit/84429912900872405b44804943357dda8430a550))
+
+# [1.0.0-dev.16](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.15...v1.0.0-dev.16) (2022-05-27)
+
+
+### Bug Fixes
+
+* `JarPatchBundle` loading non-class files to class loader ([3f0c740](https://github.com/revanced/revanced-patcher/commit/3f0c740200dd91a060426638c2f8f516938b4c53))
+* remove dependency to fork of Apktool ([0fa529f](https://github.com/revanced/revanced-patcher/commit/0fa529fcdf9a7b5ea9a361b9f9f32f3f3fce009f))
+
+
+### Features
+
+* migrate to `DexPatchBundle` and `JarPatchBundle` ([7573db2](https://github.com/revanced/revanced-patcher/commit/7573db25757de89824af4f3aea167e500120eabb))
+
+# [1.0.0-dev.15](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.14...v1.0.0-dev.15) (2022-05-25)
+
+
+### Features
+
+* utility functions to get metadata of patch & sigs ([72f16b7](https://github.com/revanced/revanced-patcher/commit/72f16b778587c28d8f8e91da502f197e7dc35d6d))
+
+# [1.0.0-dev.14](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.13...v1.0.0-dev.14) (2022-05-24)
+
+
+### Bug Fixes
+
+* reformat (trigger release) ([45a167e](https://github.com/revanced/revanced-patcher/commit/45a167e7856da0306f796953775c7b7543d9bec0))
+
+# [1.0.0-dev.13](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.12...v1.0.0-dev.13) (2022-05-24)
+
+
+### Performance Improvements
+
+* decode manifest only when not using resource patcher ([40b1fa4](https://github.com/revanced/revanced-patcher/commit/40b1fa43e1704ace29d3e349df2f4a8ea828c5c2))
+
+# [1.0.0-dev.12](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.11...v1.0.0-dev.12) (2022-05-22)
+
+
+### Bug Fixes
+
+* using old instance of `Androlib` when saving ([5630e49](https://github.com/revanced/revanced-patcher/commit/5630e4966310311cdfd53e2ba128255047626adc))
+
 # [1.0.0-dev.11](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.10...v1.0.0-dev.11) (2022-05-22)
 
 

build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    kotlin("jvm") version "1.6.20"
+    kotlin("jvm") version "1.6.21"
     java
     `maven-publish`
 }
@@ -15,8 +15,10 @@ repositories {
             // Instead, you should set them in:
             // Windows: %homepath%\.gradle\gradle.properties
             // Linux: ~/.gradle/gradle.properties
-            username = project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR") // DO NOT CHANGE!
-            password = project.findProperty("gpr.key") as String? ?: System.getenv("GITHUB_TOKEN") // DO NOT CHANGE!
+            username =
+                project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR") // DO NOT CHANGE!
+            password =
+                project.findProperty("gpr.key") as String? ?: System.getenv("GITHUB_TOKEN") // DO NOT CHANGE!
         }
     }
 }
@@ -24,6 +26,7 @@ repositories {
 dependencies {
     implementation(kotlin("stdlib"))
 
+    api("xpp3:xpp3:1.1.4c")
     api("org.apktool:apktool-lib:2.6.1")
     api("app.revanced:multidexlib2:2.5.2.r2")
     api("org.smali:smali:2.5.2")

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.0.0-dev.11
+version = 1.0.0-dev.18

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright <20> 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.
@@ -17,67 +17,101 @@
 #
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions <20>$var<61>, <20>${var}<7D>, <20>${var:-default}<7D>, <20>${var+SET}<7D>,
+#           <20>${var#prefix}<7D>, <20>${var%suffix}<7D>, and <20>$( cmd )<29>;
+#         * compound commands having a testable exit status, especially <20>case<73>;
+#         * various built-in commands including <20>command<6E>, <20>set<65>, and <20>ulimit<69>.
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       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
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
 
 # 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"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MSYS* | MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +121,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    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.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -106,80 +140,95 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# 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
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

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

@@ -1,19 +1,26 @@
 package app.revanced.patcher
 
-import app.revanced.patcher.annotation.Name
 import app.revanced.patcher.data.PatcherData
 import app.revanced.patcher.data.base.Data
 import app.revanced.patcher.data.implementation.findIndexed
-import app.revanced.patcher.extensions.findAnnotationRecursively
+import app.revanced.patcher.extensions.PatchExtensions.dependencies
+import app.revanced.patcher.extensions.PatchExtensions.patchName
+import app.revanced.patcher.extensions.nullOutputStream
 import app.revanced.patcher.patch.base.Patch
 import app.revanced.patcher.patch.implementation.BytecodePatch
 import app.revanced.patcher.patch.implementation.ResourcePatch
+import app.revanced.patcher.patch.implementation.misc.PatchResult
+import app.revanced.patcher.patch.implementation.misc.PatchResultError
 import app.revanced.patcher.patch.implementation.misc.PatchResultSuccess
-import app.revanced.patcher.signature.implementation.method.MethodSignature
 import app.revanced.patcher.signature.implementation.method.resolver.MethodSignatureResolver
 import app.revanced.patcher.util.ListBackedSet
 import brut.androlib.Androlib
 import brut.androlib.meta.UsesFramework
+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.directory.ExtFile
 import lanchon.multidexlib2.BasicDexFileNamer
 import lanchon.multidexlib2.DexIO
@@ -28,52 +35,64 @@ val NAMER = BasicDexFileNamer()
 
 /**
  * The ReVanced Patcher.
- * @param inputFile The input file (usually an apk file).
- * @param resourceCacheDirectory Directory to cache resources.
- * @param patchResources Weather to use the resource patcher. Resources will still need to be decoded.
+ * @param options The options for the patcher.
  */
 class Patcher(
-    inputFile: File,
-    // TODO: maybe a file system in memory is better. Could cause high memory usage.
-    private val resourceCacheDirectory: String,
-    private val patchResources: Boolean = false
+    private val options: PatcherOptions
 ) {
     val packageVersion: String
     val packageName: String
 
-    private val usesFramework: UsesFramework
+    private lateinit var usesFramework: UsesFramework
     private val patcherData: PatcherData
     private val opcodes: Opcodes
-    private var signaturesResolved = false
-    private val androlib = Androlib()
-
 
     init {
-        val extFileInput = ExtFile(inputFile)
-        val resourceTable = androlib.getResTable(extFileInput, true)
-        val outDir = File(resourceCacheDirectory)
+        val extFileInput = ExtFile(options.inputFile)
+        val outDir = File(options.resourceCacheDirectory)
 
         if (outDir.exists()) outDir.deleteRecursively()
         outDir.mkdir()
 
-        // 1. decode resources to cache directory
-        androlib.decodeManifestWithResources(extFileInput, outDir, resourceTable)
-        androlib.decodeResourcesFull(extFileInput, outDir, resourceTable)
+        // load the resource table from the input file
+        val androlib = Androlib()
+        val resourceTable = androlib.getResTable(extFileInput, true)
 
-        // 2. read framework ids from the resource table
-        usesFramework = UsesFramework()
-        usesFramework.ids = resourceTable.listFramePackages().map { it.id }.sorted()
+        if (options.patchResources) {
+            // 1. decode resources to cache directory
+            androlib.decodeManifestWithResources(extFileInput, outDir, resourceTable)
+            androlib.decodeResourcesFull(extFileInput, outDir, resourceTable)
 
-        // 3. read package info
-        packageName = resourceTable.packageOriginal
+            // 2. read framework ids from the resource table
+            usesFramework = UsesFramework()
+            usesFramework.ids = resourceTable.listFramePackages().map { it.id }.sorted()
+        } else {
+            // 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(
+                extFileInput.directory.getFileInput("AndroidManifest.xml"), nullOutputStream
+            )
+        }
+
+        // set package information
         packageVersion = resourceTable.versionInfo.versionName
-
+        packageName = resourceTable.currentResPackage.name
         // read dex files
-        val dexFile = MultiDexIO.readDexFile(true, inputFile, NAMER, null, null)
+        val dexFile = MultiDexIO.readDexFile(true, options.inputFile, NAMER, null, null)
         opcodes = dexFile.opcodes
 
         // save to patcher data
-        patcherData = PatcherData(dexFile.classes.toMutableList(), resourceCacheDirectory)
+        patcherData = PatcherData(dexFile.classes.toMutableList(), options.resourceCacheDirectory)
     }
 
     /**
@@ -83,9 +102,7 @@ class Patcher(
      * @param throwOnDuplicates If this is set to true, the patcher will throw an exception if a duplicate class has been found.
      */
     fun addFiles(
-        files: Iterable<File>,
-        allowedOverwrites: Iterable<String> = emptyList(),
-        throwOnDuplicates: Boolean = false
+        files: Iterable<File>, allowedOverwrites: Iterable<String> = emptyList(), throwOnDuplicates: Boolean = false
     ) {
         for (file in files) {
             val dexFile = MultiDexIO.readDexFile(true, file, NAMER, null, null)
@@ -122,50 +139,79 @@ class Patcher(
         }
 
         // build modified resources
-        if (patchResources) {
-            val extDir = ExtFile(resourceCacheDirectory)
-            androlib.buildResources(extDir, usesFramework)
+        if (options.patchResources) {
+            val extDir = ExtFile(options.resourceCacheDirectory)
+
+            // TODO: figure out why a new instance of Androlib is necessary here
+            Androlib().buildResources(extDir, usesFramework)
         }
 
         // write dex modified files
         val output = mutableMapOf<String, MemoryDataStore>()
         MultiDexIO.writeDexFile(
             true, -1, // core count
-            output, NAMER, newDexFile,
-            DexIO.DEFAULT_MAX_DEX_POOL_SIZE,
-            null
+            output, NAMER, newDexFile, DexIO.DEFAULT_MAX_DEX_POOL_SIZE, null
         )
         return output
     }
 
     /**
-     * Add a patch to the patcher.
-     * @param patches The patches to add.
+     * Add [Patch]es to the patcher.
+     * @param patches [Patch]es The patches to add.
      */
-    fun addPatches(patches: Iterable<Patch<Data>>) {
+    fun addPatches(patches: Iterable<Class<out Patch<Data>>>) {
         patcherData.patches.addAll(patches)
     }
 
     /**
-     * Resolves all signatures.
+     * Apply a [patch] and its dependencies recursively.
+     * @param patch The [patch] to apply.
+     * @param appliedPatches A list of [patch] names, to prevent applying [patch]es twice.
+     * @return The result of executing the [patch].
      */
-    fun resolveSignatures(): List<MethodSignature> {
-        val signatures = buildList {
-            for (patch in patcherData.patches) {
-                if (patch !is BytecodePatch) continue
-                this.addAll(patch.signatures)
-            }
-        }
-        if (signatures.isEmpty()) {
-            return emptyList()
+    private fun applyPatch(
+        patch: Class<out Patch<Data>>, appliedPatches: MutableList<String>
+    ): PatchResult {
+        val patchName = patch.patchName
+
+        // if the patch has already applied silently skip it
+        if (appliedPatches.contains(patchName)) return PatchResultSuccess()
+        appliedPatches.add(patchName)
+
+        // recursively apply all dependency patches
+        patch.dependencies?.forEach {
+            val patchDependency = it.java
+
+            val result = applyPatch(patchDependency, appliedPatches)
+            if (result.isSuccess()) return@forEach
+
+            val errorMessage = result.error()!!.message
+            return PatchResultError("$patchName depends on ${patchDependency.patchName} but the following error was raised: $errorMessage")
         }
 
-        MethodSignatureResolver(patcherData.bytecodeData.classes.internalClasses, signatures).resolve(patcherData)
-        signaturesResolved = true
-        return signatures
+        val patchInstance = patch.getDeclaredConstructor().newInstance()
+
+        // if the current patch is a resource patch but resource patching is disabled, return an error
+        val isResourcePatch = patchInstance is ResourcePatch
+        if (!options.patchResources && isResourcePatch) return PatchResultError("$patchName is a resource patch, but resource patching is disabled.")
+
+        // TODO: find a solution for this
+        val data = if (isResourcePatch) {
+            patcherData.resourceData
+        } else {
+            MethodSignatureResolver(
+                patcherData.bytecodeData.classes.internalClasses, (patchInstance as BytecodePatch).signatures
+            ).resolve(patcherData)
+            patcherData.bytecodeData
+        }
+
+        return try {
+            patchInstance.execute(data)
+        } catch (e: Exception) {
+            PatchResultError(e)
+        }
     }
 
-
     /**
      * Apply patches loaded into the patcher.
      * @param stopOnError If true, the patches will stop on the first error.
@@ -174,46 +220,24 @@ class Patcher(
      * If the [Patch] failed to apply, an Exception will always be returned to the wrapping Result object.
      */
     fun applyPatches(
-        stopOnError: Boolean = false,
-        callback: (String) -> Unit = {}
+        stopOnError: Boolean = false, callback: (String) -> Unit = {}
     ): Map<String, Result<PatchResultSuccess>> {
-        if (!signaturesResolved) {
-            resolveSignatures()
-        }
+        val appliedPatches = mutableListOf<String>()
+
         return buildMap {
             for (patch in patcherData.patches) {
-                val resourcePatch = patch is ResourcePatch
-                if (!patchResources && resourcePatch) continue
+                val result = applyPatch(patch, appliedPatches)
 
-                val patchNameAnnotation = patch::class.java.findAnnotationRecursively(Name::class.java)
+                val name = patch.patchName
+                callback(name)
 
-                patchNameAnnotation?.let {
-                    callback(it.name)
+                this[name] = if (result.isSuccess()) {
+                    Result.success(result.success()!!)
+                } else {
+                    Result.failure(result.error()!!)
                 }
 
-                val result: Result<PatchResultSuccess> = try {
-                    val data = if (resourcePatch) {
-                        patcherData.resourceData
-                    } else {
-                        patcherData.bytecodeData
-                    }
-
-                    val pr = patch.execute(data)
-
-                    if (pr.isSuccess()) {
-                        Result.success(pr.success()!!)
-                    } else {
-                        Result.failure(Exception(pr.error()?.errorMessage() ?: "Unknown error"))
-                    }
-                } catch (e: Exception) {
-                    Result.failure(e)
-                }
-
-                patchNameAnnotation?.let {
-                    this[patchNameAnnotation.name] = result
-                }
-
-                if (result.isFailure && stopOnError) break
+                if (stopOnError && result.isError()) break
             }
         }
     }

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

@@ -0,0 +1,15 @@
+package app.revanced.patcher
+
+import java.io.File
+
+/**
+ * @param inputFile The input file (usually an apk file).
+ * @param resourceCacheDirectory Directory to cache resources.
+ * @param patchResources Weather to use the resource patcher. Resources will still need to be decoded.
+ */
+data class PatcherOptions(
+    internal val inputFile: File,
+    // TODO: maybe a file system in memory is better. Could cause high memory usage.
+    internal val resourceCacheDirectory: String,
+    internal val patchResources: Boolean = false
+)

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

@@ -11,8 +11,8 @@ internal data class PatcherData(
     val internalClasses: MutableList<ClassDef>,
     val resourceCacheDirectory: String
 ) {
-    internal val patches = mutableListOf<Patch<Data>>()
+    internal val patches = mutableListOf<Class<out Patch<Data>>>()
 
-    internal val bytecodeData = BytecodeData(patches, internalClasses)
+    internal val bytecodeData = BytecodeData(internalClasses)
     internal val resourceData = ResourceData(File(resourceCacheDirectory))
 }

src/main/kotlin/app/revanced/patcher/data/implementation/BytecodeData.kt

@@ -1,55 +1,33 @@
 package app.revanced.patcher.data.implementation
 
 import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.patch.implementation.BytecodePatch
-import app.revanced.patcher.signature.implementation.method.resolver.SignatureResolverResult
 import app.revanced.patcher.util.ProxyBackedClassList
 import app.revanced.patcher.util.method.MethodWalker
 import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.Method
 
 class BytecodeData(
-    // FIXME: ugly solution due to design.
-    //  It does not make sense for a BytecodeData instance to have access to the patches
-    private val patches: List<Patch<Data>>,
     internalClasses: MutableList<ClassDef>
 ) : Data {
     val classes = ProxyBackedClassList(internalClasses)
 
     /**
-     * Find a class by a given class name
-     * @return A proxy for the first class that matches the class name
+     * 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
-     * @return A proxy for the first class that matches the predicate
+     * 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): app.revanced.patcher.util.proxy.ClassProxy? {
+    fun findClass(predicate: (ClassDef) -> Boolean) =
         // if we already proxied the class matching the predicate...
-        for (patch in patches) {
-            if (patch !is BytecodePatch) continue
-            for (signature in patch.signatures) {
-                val result = signature.result
-                result ?: continue
-
-                if (predicate(result.definingClassProxy.immutableClass)) return result.definingClassProxy  // ...then return that proxy
-            }
-        }
+        classes.proxies.firstOrNull { predicate(it.immutableClass) } ?:
         // else resolve the class to a proxy and return it, if the predicate is matching a class
-        return classes.find(predicate)?.let {
-            proxy(it)
-        }
-    }
-}
-
-
-class MethodMap : LinkedHashMap<String, SignatureResolverResult>() {
-    override fun get(key: String): SignatureResolverResult {
-        return super.get(key) ?: throw MethodNotFoundException("Method $key was not found in the method cache")
-    }
+        classes.find(predicate)?.let { proxy(it) }
 }
 
 internal class MethodNotFoundException(s: String) : Exception(s)
@@ -63,6 +41,11 @@ internal inline fun <reified T> Iterable<T>.find(predicate: (T) -> Boolean): T?
     return null
 }
 
+/**
+ * Create a [MethodWalker] instance for the current [BytecodeData].
+ * @param startMethod The method to start at.
+ * @return A [MethodWalker] instance.
+ */
 fun BytecodeData.toMethodWalker(startMethod: Method): MethodWalker {
     return MethodWalker(this, startMethod)
 }
@@ -80,7 +63,7 @@ fun BytecodeData.proxy(classDef: ClassDef): app.revanced.patcher.util.proxy.Clas
     var proxy = this.classes.proxies.find { it.immutableClass.type == classDef.type }
     if (proxy == null) {
         proxy = app.revanced.patcher.util.proxy.ClassProxy(classDef)
-        this.classes.proxies.add(proxy)
+        this.classes.add(proxy)
     }
     return proxy
 }

src/main/kotlin/app/revanced/patcher/data/implementation/ResourceData.kt

@@ -14,8 +14,7 @@ class ResourceData(private val resourceCacheDirectory: File) : Data {
     private fun resolve(path: String) = resourceCacheDirectory.resolve(path)
 
     fun forEach(action: (File) -> Unit) = resourceCacheDirectory.walkTopDown().forEach(action)
-    fun reader(path: String) = resolve(path).reader()
-    fun writer(path: String) = resolve(path).writer()
+    fun get(path: String) = resolve(path)
 
     fun replace(path: String, oldValue: String, newValue: String, oldValueIsRegex: Boolean = false) {
         // TODO: buffer this somehow

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

@@ -0,0 +1,57 @@
+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.base.Data
+import app.revanced.patcher.patch.base.Patch
+import app.revanced.patcher.signature.implementation.method.MethodSignature
+import app.revanced.patcher.signature.implementation.method.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.signature.implementation.method.annotation.MatchingMethod
+import kotlin.reflect.KClass
+
+/**
+ * Recursively find a given annotation on a class.
+ * @param targetAnnotation The annotation to find.
+ * @return The annotation.
+ */
+private fun <T : Annotation> Class<*>.recursiveAnnotation(targetAnnotation: KClass<T>) =
+    this.findAnnotationRecursively(targetAnnotation.java, mutableSetOf())
+
+
+private fun <T : Annotation> Class<*>.findAnnotationRecursively(
+    targetAnnotation: Class<T>, traversed: MutableSet<Annotation>
+): T? {
+    val found = this.annotations.firstOrNull { it.annotationClass.java.name == targetAnnotation.name }
+
+    @Suppress("UNCHECKED_CAST") if (found != null) return found as T
+
+    for (annotation in this.annotations) {
+        if (traversed.contains(annotation)) continue
+        traversed.add(annotation)
+
+        return (annotation.annotationClass.java.findAnnotationRecursively(targetAnnotation, traversed)) ?: continue
+    }
+
+    return null
+}
+
+object PatchExtensions {
+    val Class<out Patch<Data>>.patchName: String
+        get() = recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
+    val Class<out Patch<Data>>.version get() = recursiveAnnotation(Version::class)?.version
+    val Class<out Patch<Data>>.description get() = recursiveAnnotation(Description::class)?.description
+    val Class<out Patch<Data>>.dependencies get() = recursiveAnnotation(app.revanced.patcher.patch.annotations.Dependencies::class)?.dependencies
+    val Class<out Patch<Data>>.compatiblePackages get() = recursiveAnnotation(Compatibility::class)?.compatiblePackages
+}
+
+object MethodSignatureExtensions {
+    val MethodSignature.name: String get() = javaClass.recursiveAnnotation(Name::class)?.name ?: this.javaClass.simpleName
+    val MethodSignature.version get() = javaClass.recursiveAnnotation(Version::class)?.version ?: "0.0.1"
+    val MethodSignature.description get() = javaClass.recursiveAnnotation(Description::class)?.description
+    val MethodSignature.compatiblePackages get() = javaClass.recursiveAnnotation(Compatibility::class)?.compatiblePackages
+    val MethodSignature.matchingMethod get() = javaClass.recursiveAnnotation(MatchingMethod::class)
+    val MethodSignature.fuzzyPatternScanMethod get() = javaClass.recursiveAnnotation(FuzzyPatternScanMethod::class)
+    val MethodSignature.fuzzyThreshold get() = fuzzyPatternScanMethod?.threshold ?: 0
+}

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

@@ -9,33 +9,7 @@ import org.jf.dexlib2.iface.reference.MethodReference
 import org.jf.dexlib2.immutable.ImmutableMethod
 import org.jf.dexlib2.immutable.ImmutableMethodImplementation
 import org.jf.dexlib2.util.MethodUtil
-
-/**
- * Recursively find a given annotation on a class
- * @param targetAnnotation The annotation to find
- * @return The annotation
- */
-fun <T : Annotation> Class<*>.findAnnotationRecursively(targetAnnotation: Class<T>) =
-    this.findAnnotationRecursively(targetAnnotation, mutableSetOf())
-
-private fun <T : Annotation> Class<*>.findAnnotationRecursively(
-    targetAnnotation: Class<T>,
-    traversed: MutableSet<Annotation>
-): T? {
-    val found = this.annotations.firstOrNull { it.annotationClass.java.name == targetAnnotation.name }
-
-    @Suppress("UNCHECKED_CAST")
-    if (found != null) return found as T
-
-    for (annotation in this.annotations) {
-        if (traversed.contains(annotation)) continue
-        traversed.add(annotation)
-
-        return (annotation.annotationClass.java.findAnnotationRecursively(targetAnnotation, traversed)) ?: continue
-    }
-
-    return null
-}
+import java.io.OutputStream
 
 infix fun AccessFlags.or(other: AccessFlags) = this.value or other.value
 infix fun Int.or(other: AccessFlags) = this or other.value
@@ -46,6 +20,19 @@ fun MutableMethodImplementation.addInstructions(index: Int, instructions: List<B
     }
 }
 
+/**
+ * Compare a method to another, considering constructors and parameters.
+ * @param otherMethod The method to compare against.
+ * @return True if the methods match given the conditions.
+ */
+fun Method.softCompareTo(
+    otherMethod: MethodReference
+): Boolean {
+    if (MethodUtil.isConstructor(this) && !parametersEqual(this.parameterTypes, otherMethod.parameterTypes))
+        return false
+    return this.name == otherMethod.name
+}
+
 /**
  * Clones the method.
  * @param registerCount This parameter allows you to change the register count of the method.
@@ -85,14 +72,6 @@ internal fun Method.cloneMutable(
     registerCount: Int = 0,
 ) = clone(registerCount).toMutable()
 
-internal fun Method.softCompareTo(
-    otherMethod: MethodReference
-): Boolean {
-    if (MethodUtil.isConstructor(this) && !parametersEqual(this.parameterTypes, otherMethod.parameterTypes))
-        return false
-    return this.name == otherMethod.name
-}
-
 // FIXME: also check the order of parameters as different order equals different method overload
 internal fun parametersEqual(
     parameters1: Iterable<CharSequence>,
@@ -105,4 +84,9 @@ internal fun parametersEqual(
             )
         }
     }
-}
+}
+
+internal val nullOutputStream: OutputStream =
+    object : OutputStream() {
+        override fun write(b: Int) {}
+    }

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

@@ -1,9 +1,23 @@
 package app.revanced.patcher.patch.annotations
 
+import app.revanced.patcher.data.base.Data
+import app.revanced.patcher.patch.base.Patch
+import kotlin.reflect.KClass
+
 /**
  * Annotation to mark a Class as a patch.
  */
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @MustBeDocumented
-annotation class Patch
+annotation class Patch
+
+/**
+ * Annotation for dependencies of [Patch]es .
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class Dependencies(
+    val dependencies: Array<KClass<out Patch<Data>>> = []
+)

src/main/kotlin/app/revanced/patcher/patch/base/Patch.kt

@@ -11,8 +11,9 @@ import app.revanced.patcher.patch.implementation.misc.PatchResult
  * Can either be a [ResourcePatch] or a [BytecodePatch].
  */
 abstract class Patch<out T : Data> {
+
     /**
      * The main function of the [Patch] which the patcher will call.
      */
-    abstract fun execute(data: @UnsafeVariance T): PatchResult // FIXME: remove the UnsafeVariance annotation
+    abstract fun execute(data: @UnsafeVariance T): PatchResult
 }

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

@@ -24,10 +24,12 @@ interface PatchResult {
     }
 }
 
-class PatchResultError(private val errorMessage: String) : PatchResult {
-    fun errorMessage(): String {
-        return errorMessage
-    }
+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/signature/implementation/method/MethodSignature.kt

@@ -1,7 +1,7 @@
 package app.revanced.patcher.signature.implementation.method
 
-import app.revanced.patcher.annotation.Name
 import app.revanced.patcher.data.implementation.MethodNotFoundException
+import app.revanced.patcher.extensions.MethodSignatureExtensions.name
 import app.revanced.patcher.signature.base.Signature
 import app.revanced.patcher.signature.implementation.method.resolver.SignatureResolverResult
 import org.jf.dexlib2.Opcode
@@ -26,22 +26,8 @@ abstract class MethodSignature(
      * The result of the signature
      */
     var result: SignatureResolverResult? = null
+        @Throws(MethodNotFoundException::class)
         get() {
-            return field ?: throw MethodNotFoundException(
-                "Could not resolve required signature ${
-                    (this::class.annotations.find { it is Name }?.let {
-                        (it as Name).name
-                    })
-                }"
-            )
-        }
-    val resolved: Boolean
-        get() {
-            var resolved = false
-            try {
-                resolved = result != null
-            } catch (_: Exception) {
-            }
-            return resolved
+            return field ?: throw MethodNotFoundException("Could not resolve required signature ${this.name}")
         }
 }

src/main/kotlin/app/revanced/patcher/signature/implementation/method/annotation/MethodSignatureMetadata.kt

@@ -10,7 +10,7 @@ import app.revanced.patcher.signature.implementation.method.MethodSignature
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 annotation class MatchingMethod(
-    val definingClass: String = "L<unspecified-class>",
+    val definingClass: String = "L<unspecified-class>;",
     val name: String = "<unspecified-method>"
 )
 

src/main/kotlin/app/revanced/patcher/signature/implementation/method/resolver/MethodSignatureResolver.kt

@@ -2,10 +2,9 @@ package app.revanced.patcher.signature.implementation.method.resolver
 
 import app.revanced.patcher.data.PatcherData
 import app.revanced.patcher.data.implementation.proxy
-import app.revanced.patcher.extensions.findAnnotationRecursively
+import app.revanced.patcher.extensions.MethodSignatureExtensions.fuzzyThreshold
 import app.revanced.patcher.extensions.parametersEqual
 import app.revanced.patcher.signature.implementation.method.MethodSignature
-import app.revanced.patcher.signature.implementation.method.annotation.FuzzyPatternScanMethod
 import org.jf.dexlib2.Opcode
 import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.Method
@@ -109,9 +108,7 @@ internal class MethodSignatureResolver(
             val pattern = signature.opcodes!!
             val size = pattern.count()
 
-            val threshold =
-                signature::class.java.findAnnotationRecursively(FuzzyPatternScanMethod::class.java)?.threshold
-                    ?: 0
+            val threshold = signature.fuzzyThreshold
 
             for (instructionIndex in 0 until count) {
                 var patternIndex = 0

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

@@ -1,24 +1,21 @@
 package app.revanced.patcher.util
 
+import app.revanced.patcher.util.proxy.ClassProxy
 import org.jf.dexlib2.iface.ClassDef
 
 class ProxyBackedClassList(internal val internalClasses: MutableList<ClassDef>) : List<ClassDef> {
-    internal val proxies = mutableListOf<app.revanced.patcher.util.proxy.ClassProxy>()
+    private val internalProxies = mutableListOf<ClassProxy>()
+    internal val proxies: List<ClassProxy> = internalProxies
 
-    fun add(classDef: ClassDef) {
-        internalClasses.add(classDef)
-    }
-
-    fun add(classProxy: app.revanced.patcher.util.proxy.ClassProxy) {
-        proxies.add(classProxy)
-    }
+    fun add(classDef: ClassDef) = internalClasses.add(classDef)
+    fun add(classProxy: ClassProxy) = internalProxies.add(classProxy)
 
     /**
      * Apply all resolved classes into [internalClasses] and clean the [proxies] list.
      */
-    fun applyProxies() {
+    internal fun applyProxies() {
         // FIXME: check if this could cause issues when multiple patches use the same proxy
-        proxies.removeIf { proxy ->
+        internalProxies.removeIf { proxy ->
             // if the proxy is unused, keep it in the list
             if (!proxy.proxyUsed) return@removeIf false
 

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

@@ -33,7 +33,7 @@ class MethodWalker internal constructor(
      * @param walkMutable If this is true, the class of the method will be resolved mutably.
      * The current method will be mutable.
      */
-    fun walk(offset: Int, walkMutable: Boolean = false): MethodWalker {
+    fun nextMethod(offset: Int, walkMutable: Boolean = false): MethodWalker {
         currentMethod.implementation?.instructions?.let { instructions ->
             val instruction = instructions.elementAt(offset)
 

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

@@ -1,34 +0,0 @@
-package app.revanced.patcher.util.patch
-
-import app.revanced.patcher.patch.base.Patch
-import java.io.File
-import java.net.URLClassLoader
-import java.util.jar.JarFile
-
-object PatchLoader {
-    /**
-     * This method loads patches from a given jar file containing [Patch]es
-     * @return the loaded patches represented as a list of [Patch] classes
-     */
-    fun loadFromFile(patchesJar: File) = buildList {
-        val jarFile = JarFile(patchesJar)
-        val classLoader = URLClassLoader(arrayOf(patchesJar.toURI().toURL()))
-
-        val entries = jarFile.entries()
-        while (entries.hasMoreElements()) {
-            val entry = entries.nextElement()
-            if (!entry.name.endsWith(".class") || entry.name.contains("$")) continue
-
-            val clazz = classLoader.loadClass(entry.realName.replace('/', '.').replace(".class", ""))
-
-            if (!clazz.isAnnotationPresent(app.revanced.patcher.patch.annotations.Patch::class.java)) continue
-
-            @Suppress("UNCHECKED_CAST")
-            val patch = clazz as Class<Patch<*>>
-
-            // TODO: include declared classes from patch
-
-            this.add(patch)
-        }
-    }
-}

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

@@ -0,0 +1,18 @@
+package app.revanced.patcher.util.patch.base
+
+import app.revanced.patcher.data.base.Data
+import app.revanced.patcher.patch.base.Patch
+import java.io.File
+
+/**
+ * @param patchBundlePath The path to the patch bundle.
+ */
+abstract class PatchBundle(patchBundlePath: String) : File(patchBundlePath) {
+    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<Data>>)
+        }
+    }
+}

src/main/kotlin/app/revanced/patcher/util/patch/implementation/DexPatchBundle.kt

@@ -0,0 +1,17 @@
+package app.revanced.patcher.util.patch.implementation
+
+import app.revanced.patcher.util.patch.base.PatchBundle
+import app.revanced.patcher.util.patch.util.StringIterator
+import org.jf.dexlib2.DexFileFactory
+
+/**
+ * A patch bundle of the ReVanced [DexPatchBundle] format.
+ * @param patchBundlePath The path to a patch bundle of dex format.
+ * @param dexClassLoader The dex class loader.
+ */
+class DexPatchBundle(patchBundlePath: String, private val dexClassLoader: ClassLoader) : PatchBundle(patchBundlePath) {
+    fun loadPatches() = loadPatches(dexClassLoader,
+        StringIterator(DexFileFactory.loadDexFile(path, null).classes.iterator()) { classDef ->
+            classDef.type.substring(1, classDef.length - 1).replace('/', '.')
+        })
+}

src/main/kotlin/app/revanced/patcher/util/patch/implementation/JarPatchBundle.kt

@@ -0,0 +1,30 @@
+package app.revanced.patcher.util.patch.implementation
+
+import app.revanced.patcher.util.patch.base.PatchBundle
+import app.revanced.patcher.util.patch.util.StringIterator
+import java.net.URLClassLoader
+import java.util.jar.JarFile
+
+/**
+ * A patch bundle of the ReVanced [JarPatchBundle] format.
+ * @param patchBundlePath The path to the patch bundle.
+ */
+class JarPatchBundle(patchBundlePath: String) : PatchBundle(patchBundlePath) {
+    fun loadPatches() = loadPatches(
+        URLClassLoader(
+            arrayOf(this.toURI().toURL()),
+            Thread.currentThread().contextClassLoader // TODO: find out why this is required
+        ),
+        StringIterator(
+            JarFile(this)
+                .entries()
+                .toList() // TODO: find a cleaner solution than that to filter non class files
+                .filter {
+                    it.name.endsWith(".class") && !it.name.contains("$")
+                }
+                .iterator()
+        ) {
+            it.realName.replace('/', '.').replace(".class", "")
+        }
+    )
+}

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

@@ -0,0 +1,10 @@
+package app.revanced.patcher.util.patch.util
+
+internal class StringIterator<T, I : Iterator<T>>(
+    private val iterator: I,
+    private val _next: (T) -> String
+) : Iterator<String> {
+    override fun hasNext() = iterator.hasNext()
+
+    override fun next() = _next(iterator.next())
+}

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

@@ -13,9 +13,9 @@ import org.jf.smali.smaliTreeWalker
 import java.io.InputStreamReader
 
 private const val METHOD_TEMPLATE = """
-.class public Linlinecompiler;
+.class LInlineCompiler;
 .super Ljava/lang/Object;
-.method public static compiler(%s)V
+.method %s dummyMethod(%s)V
     .registers %d
     %s
 .end method
@@ -35,9 +35,10 @@ class InlineSmaliCompiler {
         fun compileMethodInstructions(
             instructions: String,
             parameters: String,
-            registers: Int
+            registers: Int,
+            forStaticMethod: Boolean
         ): List<BuilderInstruction> {
-            val input = METHOD_TEMPLATE.format(parameters, registers, instructions)
+            val input = METHOD_TEMPLATE.format(if (forStaticMethod) "static" else "", parameters, registers, instructions)
             val reader = InputStreamReader(input.byteInputStream())
             val lexer: LexerErrorInterface = smaliFlexLexer(reader, 15)
             val tokens = CommonTokenStream(lexer as TokenSource)
@@ -58,8 +59,8 @@ class InlineSmaliCompiler {
     }
 }
 
-fun String.toInstructions(parameters: String = "", registers: Int = 1) =
-    InlineSmaliCompiler.compileMethodInstructions(this, parameters, registers)
+fun String.toInstructions(parameters: String = "", registers: Int = 1, forStaticMethod: Boolean = true) =
+    InlineSmaliCompiler.compileMethodInstructions(this, parameters, registers, forStaticMethod)
 
-fun String.toInstruction(parameters: String = "", registers: Int = 1) =
-    this.toInstructions(parameters, registers).first()
+fun String.toInstruction(parameters: String = "", registers: Int = 1, forStaticMethod: Boolean = true) =
+    this.toInstructions(parameters, registers, forStaticMethod).first()

src/test/kotlin/app/revanced/patcher/usage/PatcherTest.kt

@@ -1,4 +1,4 @@
-package app.revanced.patcher
+package app.revanced.patcher.usage
 
 import org.junit.jupiter.api.Test
 

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

@@ -18,21 +18,17 @@ import org.w3c.dom.Element
 @Version("0.0.1")
 class ExampleResourcePatch : ResourcePatch() {
     override fun execute(data: ResourceData): PatchResult {
-        val editor = data.getXmlEditor("AndroidManifest.xml")
-
-        // regular DomFileEditor
-        val element = editor
-            .file
-            .getElementsByTagName("application")
-            .item(0) as Element
-        element
-            .setAttribute(
-                "exampleAttribute",
-                "exampleValue"
-            )
-
-        // close the editor to write changes
-        editor.close()
+        data.getXmlEditor("AndroidManifest.xml").use { domFileEditor ->
+            val element = domFileEditor // regular DomFileEditor
+                .file
+                .getElementsByTagName("application")
+                .item(0) as Element
+            element
+                .setAttribute(
+                    "exampleAttribute",
+                    "exampleValue"
+                )
+        }
 
         // iterate through all available resources
         data.forEach {