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

# [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)

.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
+

.github/ISSUE_TEMPLATE/bug-issue.yml

@@ -0,0 +1,72 @@
+name: 🐞 Bug report
+description: Report a very clearly broken issue.
+title: 'bug: <title>'
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # ReVanced bug report
+
+        Important to note that your issue may have already been reported before. Please check for existing issues [here](https://github.com/revanced/revanced-patcher/labels/bug).
+
+  - type: dropdown
+    attributes:
+      label: Type
+      options:
+        - Crash
+        - Cosmetic
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Bug description
+      description: How did you find the bug? Any additional details that might help?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: Add the steps to reproduce this bug including your environment.
+      placeholder: Step 1. Download some files. Step 2. ...
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Screenshots or videos
+      description: Add screenshots or videos that show the bug here.
+      placeholder: Drag and drop the screenshots/videos into this box.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Solution
+      description: If applicable, add a possible solution.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add additional context here.
+    validations:
+      required: false
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your issue will be closed if you haven't done these steps.
+      options:
+        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: I filled out all of the requested information in this issue properly.
+          required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 📃 Documentation
+    url: https://github.com/revanced/revanced-documentation/
+    about: Don't know how or where to start? Check out our documentation!
+  - name: 🗨 Discussions
+    url: https://github.com/revanced/revanced-suggestions/discussions
+    about: Got something you think should change or be added? Search for or start a new discussion!

.github/ISSUE_TEMPLATE/feature-issue.yml

@@ -0,0 +1,58 @@
+name: ⭐ Feature request
+description: Create a detailed feature request.
+title: 'feat: <title>'
+labels: [feature-request]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # ReVanced feature request
+        
+        Do not submit requests for patches here. Please submit them [here](https://github.com/orgs/revanced/discussions/categories/patches) instead.
+        Important to note that your feature request may have already been made before. Please check for existing feature requests [here](https://github.com/revanced/revanced-patcher/labels/feature-request).
+
+  - type: dropdown
+    attributes:
+      label: Type
+      options:
+        - Functionality
+        - Cosmetic
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Issue
+      description: What is the current problem. Why does it require a feature request?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Feature
+      description: Describe your feature in detail. How does it solve the issue?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Motivation
+      description: Why should your feature should be considered?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add additional context here.
+    validations:
+      required: false
+  - type: checkboxes
+    id: acknowledgements
+    attributes:
+      label: Acknowledgements
+      description: Your issue will be closed if you haven't done these steps.
+      options:
+        - label: I have searched the existing issues and this is a new and no duplicate or related to another open issue.
+          required: true
+        - label: I have written a short but informative title.
+          required: true
+        - label: I filled out all of the requested information in this issue properly.
+          required: true

.github/config.yml

@@ -0,0 +1,2 @@
+firstPRMergeComment: >
+  Thank you for contributing to ReVanced. Join us on [Discord](https://revanced.app/discord) if you want to receive a contributor role.

.github/workflows/pull_request.yml

@@ -0,0 +1,25 @@
+name: PR to main
+
+on:
+  push:
+    branches:
+      - dev
+  workflow_dispatch:
+
+env:
+  MESSAGE: merge branch `${{ github.head_ref || github.ref_name }}` to `main`
+
+jobs:
+  pull-request:
+    name: Open pull request
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Open pull request
+        uses: repo-sync/pull-request@v2
+        with:
+          destination_branch: 'main'
+          pr_title: 'chore: ${{ env.MESSAGE }}'
+          pr_body: 'This pull request will ${{ env.MESSAGE }}.'
+          pr_draft: true

.github/workflows/release.yml

@@ -1,4 +1,5 @@
 name: Release
+
 on:
   workflow_dispatch:
   push:
@@ -9,32 +10,36 @@ on:
     branches:
       - main
       - dev
+
 jobs:
   release:
     name: Release
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
+          # Make sure the release step uses its own credentials:
+          # https://github.com/cycjimmy/semantic-release-action#private-packages
+          persist-credentials: false
           fetch-depth: 0
-      - name: Setup JDK
-        uses: actions/setup-java@v2
+      - name: Cache
+        uses: actions/cache@v3
         with:
-          java-version: '17'
-          distribution: 'adopt'
-          cache: gradle
-      - name: Setup Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: "lts/*"
+          path: |
+            ${{ runner.home }}/.gradle/caches
+            ${{ runner.home }}/.gradle/wrapper
+            .gradle
+            build
+            node_modules
+          key: ${{ runner.os }}-gradle-npm-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'package-lock.json') }}
       - name: Build with Gradle
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: ./gradlew build
+        run: ./gradlew clean --no-daemon
       - name: Setup semantic-release
-        run: npm install -g semantic-release @semantic-release/git @semantic-release/changelog gradle-semantic-release-plugin -D
+        run: npm install
       - name: Release
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npx semantic-release
+          GITHUB_TOKEN: ${{ secrets.REPOSITORY_PUSH_ACCESS }}
+        run: npm exec semantic-release

.gitignore

@@ -74,6 +74,7 @@ cmake-build-*/
 
 # IntelliJ
 out/
+.idea/
 
 # mpeltonen/sbt-idea plugin
 .idea_modules/
@@ -115,3 +116,9 @@ gradle-app.setting
 
 # Avoid ignoring test resources
 !src/test/resources/*
+
+# Dependency directories
+node_modules/
+
+# Gradle props, to avoid sharing the gpr key
+gradle.properties

.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/codeStyles/Project.xml

@@ -1,10 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <JetCodeStyleSettings>
-      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
-    </JetCodeStyleSettings>
-    <codeStyleSettings language="kotlin">
-      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
-    </codeStyleSettings>
-  </code_scheme>
-</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-  </state>
-</component>

.idea/discord.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DiscordProjectSettings">
-    <option name="show" value="PROJECT_FILES" />
-    <option name="description" value="" />
-  </component>
-</project>

.idea/git_toolbox_prj.xml

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GitToolBoxProjectSettings">
-    <option name="commitMessageIssueKeyValidationOverride">
-      <BoolValueOverride>
-        <option name="enabled" value="true" />
-      </BoolValueOverride>
-    </option>
-    <option name="commitMessageValidationEnabledOverride">
-      <BoolValueOverride>
-        <option name="enabled" value="true" />
-      </BoolValueOverride>
-    </option>
-  </component>
-</project>

.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="UnusedSymbol" enabled="false" level="WARNING" enabled_by_default="false" />
-  </profile>
-</component>

.idea/misc.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="FrameworkDetectionExcludesConfiguration">
-    <file type="web" url="file://$PROJECT_DIR$" />
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="azul-17" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

.idea/vcs.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CommitMessageInspectionProfile">
-    <profile version="1.0">
-      <inspection_tool class="CommitFormat" enabled="true" level="WARNING" enabled_by_default="true" />
-      <inspection_tool class="CommitNamingConvention" enabled="true" level="WARNING" enabled_by_default="true" />
-    </profile>
-  </component>
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

.releaserc

@@ -7,11 +7,13 @@
     }
   ],
   "plugins": [
-    ["@semantic-release/commit-analyzer", {
-      "releaseRules": [
-        {"type": "build", "release": "patch"}
-      ]
-    }],
+    [
+      "@semantic-release/commit-analyzer", {
+        "releaseRules": [
+          { "type": "build", "scope": "Needs bump", "release": "patch" }
+        ]
+      }
+    ],
     "@semantic-release/release-notes-generator",
     "@semantic-release/changelog",
     "gradle-semantic-release-plugin",
@@ -24,6 +26,18 @@
         ]
       }
     ],
-    "@semantic-release/github"
+    [
+      "@saithodev/semantic-release-backmerge",
+      {
+        backmergeBranches: [{"from": "main", "to": "dev"}],
+        clearWorkspace: true
+      }
+    ],
+    [
+        "@semantic-release/github",
+        {
+            successComment: false
+        }
+    ]
   ]
 }

CHANGELOG.md

@@ -1,3 +1,875 @@
+# [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)
+
+
+### Bug Fixes
+
+* use `versionCode` if `versionName` is unavailable ([6e1b647](https://github.com/revanced/revanced-patcher/commit/6e1b6479b677657c226693e9cc6b63f4ef2ee060))
+
+## [11.0.2-dev.1](https://github.com/revanced/revanced-patcher/compare/v11.0.1...v11.0.2-dev.1) (2023-06-14)
+
+
+### Bug Fixes
+
+* catch exceptions from closing patches ([d5d6f85](https://github.com/revanced/revanced-patcher/commit/d5d6f85084c03ed9c776632823ca12394a716167))
+* only close succeeded patches ([b8151eb](https://github.com/revanced/revanced-patcher/commit/b8151ebccb5b27dd9e06fa63235cf9baeef1c0ee))
+
+## [11.0.1](https://github.com/revanced/revanced-patcher/compare/v11.0.0...v11.0.1) (2023-06-12)
+
+
+### Bug Fixes
+
+* revert using `OutputStream.nullOutputStream` ([f02a426](https://github.com/revanced/revanced-patcher/commit/f02a42610b7698fc8cc6bc5183c9ccba2ed96cda))
+
+## [11.0.1-dev.1](https://github.com/revanced/revanced-patcher/compare/v11.0.0...v11.0.1-dev.1) (2023-06-12)
+
+
+### Bug Fixes
+
+* revert using `OutputStream.nullOutputStream` ([f02a426](https://github.com/revanced/revanced-patcher/commit/f02a42610b7698fc8cc6bc5183c9ccba2ed96cda))
+
+# [11.0.0](https://github.com/revanced/revanced-patcher/compare/v10.0.0...v11.0.0) (2023-06-10)
+
+
+### Bug Fixes
+
+* add imports to fix failing tests ([43d6868](https://github.com/revanced/revanced-patcher/commit/43d6868d1f59922f9812f3e4a2a890f3b331def6))
+
+
+* refactor!: move extension functions to their corresponding classes ([a12fe7d](https://github.com/revanced/revanced-patcher/commit/a12fe7dd9e976c38a0a82fe35e6650f58f815de4))
+* refactor!: use proper extension function names ([efdd01a](https://github.com/revanced/revanced-patcher/commit/efdd01a9886b6f06af213731824621964367b2a3))
+* fix!: implement extension functions consistently ([aacf900](https://github.com/revanced/revanced-patcher/commit/aacf9007647b1cc11bc40053625802573efda6ef))
+
+
+### BREAKING CHANGES
+
+* This changes the import paths for extension functions.
+* This changes the names of extension functions
+* This changes the name of functions
+
+# [11.0.0-dev.2](https://github.com/revanced/revanced-patcher/compare/v11.0.0-dev.1...v11.0.0-dev.2) (2023-06-09)
+
+
+### Bug Fixes
+
+* add imports to fix failing tests ([43d6868](https://github.com/revanced/revanced-patcher/commit/43d6868d1f59922f9812f3e4a2a890f3b331def6))
+
+# [11.0.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v10.0.0...v11.0.0-dev.1) (2023-06-07)
+
+
+* refactor!: move extension functions to their corresponding classes ([a12fe7d](https://github.com/revanced/revanced-patcher/commit/a12fe7dd9e976c38a0a82fe35e6650f58f815de4))
+* refactor!: use proper extension function names ([efdd01a](https://github.com/revanced/revanced-patcher/commit/efdd01a9886b6f06af213731824621964367b2a3))
+* fix!: implement extension functions consistently ([aacf900](https://github.com/revanced/revanced-patcher/commit/aacf9007647b1cc11bc40053625802573efda6ef))
+
+
+### BREAKING CHANGES
+
+* This changes the import paths for extension functions.
+* This changes the names of extension functions
+* This changes the name of functions
+
+# [10.0.0](https://github.com/revanced/revanced-patcher/compare/v9.0.0...v10.0.0) (2023-06-07)
+
+
+* fix!: check for two methods parameters orders (#183) ([b6d6a75](https://github.com/revanced/revanced-patcher/commit/b6d6a7591ba1c0b48ffdef52352709564da8d9be)), closes [#183](https://github.com/revanced/revanced-patcher/issues/183)
+
+
+### BREAKING CHANGES
+
+* This requires changes to `MethodFingerprint`
+
+# [10.0.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v9.0.0...v10.0.0-dev.1) (2023-06-07)
+
+
+* fix!: check for two methods parameters orders (#183) ([b6d6a75](https://github.com/revanced/revanced-patcher/commit/b6d6a7591ba1c0b48ffdef52352709564da8d9be)), closes [#183](https://github.com/revanced/revanced-patcher/issues/183)
+
+
+### BREAKING CHANGES
+
+* This requires changes to `MethodFingerprint`
+
+# [9.0.0](https://github.com/revanced/revanced-patcher/compare/v8.0.0...v9.0.0) (2023-05-23)
+
+
+* refactor!: rename parameter ([526a3d7](https://github.com/revanced/revanced-patcher/commit/526a3d7c359e2d95d26756da0f88d5ce975f5d9b))
+
+
+### BREAKING CHANGES
+
+* This changes named parameters.
+
+# [9.0.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v8.0.0...v9.0.0-dev.1) (2023-05-23)
+
+
+* refactor!: rename parameter ([526a3d7](https://github.com/revanced/revanced-patcher/commit/526a3d7c359e2d95d26756da0f88d5ce975f5d9b))
+
+
+### BREAKING CHANGES
+
+* This changes named parameters.
+
+# [8.0.0](https://github.com/revanced/revanced-patcher/compare/v7.1.1...v8.0.0) (2023-05-13)
+
+
+* feat!: add `classDef` parameter to `MethodFingerprint` (#175) ([a205220](https://github.com/revanced/revanced-patcher/commit/a2052202b23037150df6aadc47f6e91efcd481cf)), closes [#175](https://github.com/revanced/revanced-patcher/issues/175)
+
+
+### BREAKING CHANGES
+
+* This changes the signature of the `customFingerprint` function.
+
+# [8.0.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v7.1.1...v8.0.0-dev.1) (2023-05-10)
+
+
+* feat!: add `classDef` parameter to `MethodFingerprint` (#175) ([a205220](https://github.com/revanced/revanced-patcher/commit/a2052202b23037150df6aadc47f6e91efcd481cf)), closes [#175](https://github.com/revanced/revanced-patcher/issues/175)
+
+
+### BREAKING CHANGES
+
+* This changes the signature of the `customFingerprint` function.
+
+## [7.1.1](https://github.com/revanced/revanced-patcher/compare/v7.1.0...v7.1.1) (2023-05-07)
+
+
+### Bug Fixes
+
+* remove `count` instead of `count + 1` instructions with `removeInstructions` ([#167](https://github.com/revanced/revanced-patcher/issues/167)) ([98f8eed](https://github.com/revanced/revanced-patcher/commit/98f8eedecd72b0afe6a0f099a3641a1cc6be2698))
+
+## [7.1.1-dev.1](https://github.com/revanced/revanced-patcher/compare/v7.1.0...v7.1.1-dev.1) (2023-05-07)
+
+
+### Bug Fixes
+
+* remove `count` instead of `count + 1` instructions with `removeInstructions` ([#167](https://github.com/revanced/revanced-patcher/issues/167)) ([98f8eed](https://github.com/revanced/revanced-patcher/commit/98f8eedecd72b0afe6a0f099a3641a1cc6be2698))
+
+# [7.1.0](https://github.com/revanced/revanced-patcher/compare/v7.0.0...v7.1.0) (2023-05-05)
+
+
+### Features
+
+* add appreciation message for new contributors ([d674362](https://github.com/revanced/revanced-patcher/commit/d67436271ddca9ccfe008272c1ca82c6123ae7ee))
+* add overload to get instruction as type ([49c173d](https://github.com/revanced/revanced-patcher/commit/49c173dc14137ddd198a611e9882dc71300831ee))
+
+# [7.1.0-dev.2](https://github.com/revanced/revanced-patcher/compare/v7.1.0-dev.1...v7.1.0-dev.2) (2023-05-05)
+
+
+### Features
+
+* add overload to get instruction as type ([49c173d](https://github.com/revanced/revanced-patcher/commit/49c173dc14137ddd198a611e9882dc71300831ee))
+
+# [7.1.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v7.0.0...v7.1.0-dev.1) (2023-04-30)
+
+
+### Features
+
+* add appreciation message for new contributors ([d674362](https://github.com/revanced/revanced-patcher/commit/d67436271ddca9ccfe008272c1ca82c6123ae7ee))
+
+# [7.0.0](https://github.com/revanced/revanced-patcher/compare/v6.4.3...v7.0.0) (2023-02-26)
+
+
+* feat!: merge integrations only when necessary ([6e24a85](https://github.com/revanced/revanced-patcher/commit/6e24a85eabd1e7a1484fad229d5ba55c3ba1f1b4))
+
+
+### BREAKING CHANGES
+
+* `Patcher.addFiles` is now renamed to `Patcher.addIntegrations`
+
+Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>
+
+# [7.0.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.4.3...v7.0.0-dev.1) (2023-02-26)
+
+
+* feat!: merge integrations only when necessary ([6e24a85](https://github.com/revanced/revanced-patcher/commit/6e24a85eabd1e7a1484fad229d5ba55c3ba1f1b4))
+
+
+### BREAKING CHANGES
+
+* `Patcher.addFiles` is now renamed to `Patcher.addIntegrations`
+
+Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>
+
+## [6.4.3](https://github.com/revanced/revanced-patcher/compare/v6.4.2...v6.4.3) (2023-02-10)
+
+
+### Bug Fixes
+
+* check `CONST_STRING_JUMP` instructions for matching string ([058d292](https://github.com/revanced/revanced-patcher/commit/058d292ad5e297f4c652ff543c13e77a39f7fb1b))
+
+## [6.4.3-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.4.2...v6.4.3-dev.1) (2023-02-10)
+
+
+### Bug Fixes
+
+* check `CONST_STRING_JUMP` instructions for matching string ([058d292](https://github.com/revanced/revanced-patcher/commit/058d292ad5e297f4c652ff543c13e77a39f7fb1b))
+
+## [6.4.2](https://github.com/revanced/revanced-patcher/compare/v6.4.1...v6.4.2) (2023-01-17)
+
+
+### Bug Fixes
+
+* resolve failing builds ([a263fdf](https://github.com/revanced/revanced-patcher/commit/a263fdfd413fc05098e28d4800e36ce7d313085b))
+
+## [6.4.2-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.4.1...v6.4.2-dev.1) (2023-01-17)
+
+
+### Bug Fixes
+
+* resolve failing builds ([a263fdf](https://github.com/revanced/revanced-patcher/commit/a263fdfd413fc05098e28d4800e36ce7d313085b))
+
+## [6.4.1](https://github.com/revanced/revanced-patcher/compare/v6.4.0...v6.4.1) (2023-01-15)
+
+
+### Bug Fixes
+
+* update dependency `app.revanced:multidexlib2` ([#150](https://github.com/revanced/revanced-patcher/issues/150)) ([dd7dd38](https://github.com/revanced/revanced-patcher/commit/dd7dd383577dcfc95e97f77b446a89b41b589dc0))
+
+## [6.4.1](https://github.com/revanced/revanced-patcher/compare/v6.4.0...v6.4.1) (2023-01-15)
+
+
+### Bug Fixes
+
+* update dependency `app.revanced:multidexlib2` ([#150](https://github.com/revanced/revanced-patcher/issues/150)) ([dd7dd38](https://github.com/revanced/revanced-patcher/commit/dd7dd383577dcfc95e97f77b446a89b41b589dc0))
+
+## [6.4.1-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.4.0...v6.4.1-dev.1) (2023-01-15)
+
+
+### Bug Fixes
+
+* update dependency `app.revanced:multidexlib2` ([#150](https://github.com/revanced/revanced-patcher/issues/150)) ([dd7dd38](https://github.com/revanced/revanced-patcher/commit/dd7dd383577dcfc95e97f77b446a89b41b589dc0))
+
+# [6.4.0](https://github.com/revanced/revanced-patcher/compare/v6.3.2...v6.4.0) (2023-01-02)
+
+
+### Features
+
+* add missing setter to `MutableMethod` ([8f3ecc3](https://github.com/revanced/revanced-patcher/commit/8f3ecc318c39f0270aff53efdee7a1c8d82af421))
+* do not fix methods or methods in class merger ([4102f43](https://github.com/revanced/revanced-patcher/commit/4102f43b8a9473fd0ee96c5d4fb8f6e9b4e30e70))
+* fix method and field access when merging classes ([5c09ef7](https://github.com/revanced/revanced-patcher/commit/5c09ef7837f9b731e137b66c19da77f63c007595))
+* make `aaptPath` nullable ([#146](https://github.com/revanced/revanced-patcher/issues/146)) ([9f0a09a](https://github.com/revanced/revanced-patcher/commit/9f0a09a7569fd5dd78afa27cb66a73d1662edc69))
+
+# [6.4.0-dev.2](https://github.com/revanced/revanced-patcher/compare/v6.4.0-dev.1...v6.4.0-dev.2) (2023-01-02)
+
+
+### Features
+
+* add missing setter to `MutableMethod` ([8f3ecc3](https://github.com/revanced/revanced-patcher/commit/8f3ecc318c39f0270aff53efdee7a1c8d82af421))
+* do not fix methods or methods in class merger ([4102f43](https://github.com/revanced/revanced-patcher/commit/4102f43b8a9473fd0ee96c5d4fb8f6e9b4e30e70))
+* fix method and field access when merging classes ([5c09ef7](https://github.com/revanced/revanced-patcher/commit/5c09ef7837f9b731e137b66c19da77f63c007595))
+
+# [6.4.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.3.2...v6.4.0-dev.1) (2022-12-20)
+
+
+### Features
+
+* make `aaptPath` nullable ([#146](https://github.com/revanced/revanced-patcher/issues/146)) ([9f0a09a](https://github.com/revanced/revanced-patcher/commit/9f0a09a7569fd5dd78afa27cb66a73d1662edc69))
+
+## [6.3.2](https://github.com/revanced/revanced-patcher/compare/v6.3.1...v6.3.2) (2022-12-18)
+
+
+### Bug Fixes
+
+* check if fingerprint string is substring of any string references ([c5de9e2](https://github.com/revanced/revanced-patcher/commit/c5de9e29889dffd18b31e62a892881cc48e8b607))
+* print full exception when patch fails ([7cf79e6](https://github.com/revanced/revanced-patcher/commit/7cf79e68e0e9dfd9faddee33139b127b71882d3e))
+
+## [6.3.2-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.3.1...v6.3.2-dev.1) (2022-12-18)
+
+
+### Bug Fixes
+
+* check if fingerprint string is substring of any string references ([c5de9e2](https://github.com/revanced/revanced-patcher/commit/c5de9e29889dffd18b31e62a892881cc48e8b607))
+* print full exception when patch fails ([7cf79e6](https://github.com/revanced/revanced-patcher/commit/7cf79e68e0e9dfd9faddee33139b127b71882d3e))
+
+## [6.3.2-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.3.1...v6.3.2-dev.1) (2022-12-17)
+
+
+### Bug Fixes
+
+* print full exception when patch fails ([27a8401](https://github.com/revanced/revanced-patcher/commit/27a8401d81e078e0303f7ddcb0ac6f342f8e4def))
+
+## [6.3.1](https://github.com/revanced/revanced-patcher/compare/v6.3.0...v6.3.1) (2022-12-13)
+
+
+### Bug Fixes
+
+* publicize types when merging files if necessary ([#137](https://github.com/revanced/revanced-patcher/issues/137)) ([9ec720e](https://github.com/revanced/revanced-patcher/commit/9ec720e983785d8b1dde330cc0e0e0f914c1803c))
+
+## [6.3.1-dev.1](https://github.com/revanced/revanced-patcher/compare/v6.3.0...v6.3.1-dev.1) (2022-12-13)
+
+
+### Bug Fixes
+
+* publicize types when merging files if necessary ([#137](https://github.com/revanced/revanced-patcher/issues/137)) ([9ec720e](https://github.com/revanced/revanced-patcher/commit/9ec720e983785d8b1dde330cc0e0e0f914c1803c))
+
+# [6.3.0](https://github.com/revanced/revanced-patcher/compare/v6.2.0...v6.3.0) (2022-12-02)
+
+
+### Features
+
+* sort patches in lexicographical order ([a306561](https://github.com/revanced/revanced-patcher/commit/a306561b55ac848792046378f582a036f7ffab03)), closes [#125](https://github.com/revanced/revanced-patcher/issues/125)
+
+# [6.2.0](https://github.com/revanced/revanced-patcher/compare/v6.1.1...v6.2.0) (2022-12-02)
+
+
+### Features
+
+* merge classes on addition ([#127](https://github.com/revanced/revanced-patcher/issues/127)) ([a925650](https://github.com/revanced/revanced-patcher/commit/a9256500440f9b4117f1b8813ba0097dafee4ebb))
+
+## [6.1.1](https://github.com/revanced/revanced-patcher/compare/v6.1.0...v6.1.1) (2022-11-25)
+
+
+### Bug Fixes
+
+* use `MethodUtil.methodSignaturesMatch` instead of `Method.softCompareTo` ([bd053b7](https://github.com/revanced/revanced-patcher/commit/bd053b7e9974c0282d56e6762459db7070452e4a))
+
+# [6.1.0](https://github.com/revanced/revanced-patcher/compare/v6.0.2...v6.1.0) (2022-11-22)
+
+
+### Features
+
+* apply changes from ReVanced Patcher ([ba9d998](https://github.com/revanced/revanced-patcher/commit/ba9d99868103406fe36b9aa0cfaa0ed5023edfab))
+
+## [6.0.2](https://github.com/revanced/revanced-patcher/compare/v6.0.1...v6.0.2) (2022-11-18)
+
+
+### Bug Fixes
+
+* fallback to patch class name instead of `java.lang.Class` class name ([4164cb0](https://github.com/revanced/revanced-patcher/commit/4164cb0deacc7e1eed9fce63dab030180f28b762))
+
+## [6.0.1](https://github.com/revanced/revanced-patcher/compare/v6.0.0...v6.0.1) (2022-11-14)
+
+
+### Bug Fixes
+
+* remove unnecessary dummy nop instructions ([#111](https://github.com/revanced/revanced-patcher/issues/111)) ([f9bc95f](https://github.com/revanced/revanced-patcher/commit/f9bc95f220aa434308ce6950ba6ad2e7efac9c8a))
+
+# [6.0.0](https://github.com/revanced/revanced-patcher/compare/v5.1.2...v6.0.0) (2022-10-05)
+
+
+### Code Refactoring
+
+* improve structuring of classes and their implementations ([4aa14bb](https://github.com/revanced/revanced-patcher/commit/4aa14bbb858af9253eae9328b759f3298b65a215))
+
+
+### Features
+
+* remove unused annotation `DirectPatternScanMethod` ([538b2a8](https://github.com/revanced/revanced-patcher/commit/538b2a859962570c700362afc88704ed3611aa87))
+* remove unused annotation `SincePatcher` ([4ae9ad0](https://github.com/revanced/revanced-patcher/commit/4ae9ad09d64a3f69512ccb037f816cb847d7350f))
+* remove unused extension `dependsOn` ([797286b](https://github.com/revanced/revanced-patcher/commit/797286b7588646272dea2fd35e8e78b0ffb18a0f))
+* remove unused patch extensions ([5583904](https://github.com/revanced/revanced-patcher/commit/55839049948033ad02414517fd3ba03619216aec))
+
+
+### BREAKING CHANGES
+
+* various changes in which packages classes previously where and their implementation
+* These extensions do not exist anymore and any use should be removed
+* The extension does not exist anymore and any use should be removed
+* The annotation does not exist anymore and any use should be removed
+
+## [5.1.2](https://github.com/revanced/revanced-patcher/compare/v5.1.1...v5.1.2) (2022-09-29)
+
+
+### Bug Fixes
+
+* check dependencies for resource patches ([9c07ffc](https://github.com/revanced/revanced-patcher/commit/9c07ffcc7af9f088426528561f4321c5cc6b5b15))
+* use instruction index instead of strings list index for `StringMatch` ([843e62a](https://github.com/revanced/revanced-patcher/commit/843e62ad290ee0a707be9322ee943921da3ea420))
+
+## [5.1.1](https://github.com/revanced/revanced-patcher/compare/v5.1.0...v5.1.1) (2022-09-26)
+
+
+### Performance Improvements
+
+* decode resources only when necessary ([3ba4be2](https://github.com/revanced/revanced-patcher/commit/3ba4be240bf0a424e4bbfbaca9605644fda0984e))
+
+# [5.1.0](https://github.com/revanced/revanced-patcher/compare/v5.0.1...v5.1.0) (2022-09-26)
+
+
+### Features
+
+* RwLock for opening files in `DomFileEditor` ([db4348c](https://github.com/revanced/revanced-patcher/commit/db4348c4faf51bfe29678baacfbe76ba645ec0b9))
+
+## [5.0.1](https://github.com/revanced/revanced-patcher/compare/v5.0.0...v5.0.1) (2022-09-23)
+
+
+### Reverts
+
+* revert breaking changes ([#106](https://github.com/revanced/revanced-patcher/issues/106)) ([124332f](https://github.com/revanced/revanced-patcher/commit/124332f0e9bbdaf4f1aeeb6a31333093eeba1642))
+
+# [5.0.0](https://github.com/revanced/revanced-patcher/compare/v4.5.0...v5.0.0) (2022-09-21)
+
+
+### Bug Fixes
+
+* **tests:** access `patternScanResult` through `scanResult` ([76676fb](https://github.com/revanced/revanced-patcher/commit/76676fb5673a9e92517ee3a13943cdc98dd5102a))
+
+
+* refactor!: move utility methods from `MethodFingerprintUtils` `MethodFingerprint` ([d802ef8](https://github.com/revanced/revanced-patcher/commit/d802ef844edf65d4d26328d6ca72e3ddd5a52b15))
+* feat(fingerprint)!: `StringsScanResult` for `MethodFingerprint` ([3813e28](https://github.com/revanced/revanced-patcher/commit/3813e28ac2ad6710d8d935526ca679e7b1b5980e))
+
+
+### BREAKING CHANGES
+
+* Imports will have to be updated from `MethodFingerprintUtils` to `MethodFingerprint.Companion`.
+
+Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>
+* `MethodFingerprint` now has a field for `MethodFingerprintScanResult`. `MethodFingerprintScanResult` now holds the previous field `MethodFingerprint.patternScanResult`.
+
+Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>
+
+# [4.5.0](https://github.com/revanced/revanced-patcher/compare/v4.4.2...v4.5.0) (2022-09-20)
+
+
+### Features
+
+* section `acknowledgements` for issue templates ([a0cb449](https://github.com/revanced/revanced-patcher/commit/a0cb449c60310917141e2809abaa16b4174dc002))
+
+## [4.4.2](https://github.com/revanced/revanced-patcher/compare/v4.4.1...v4.4.2) (2022-09-18)
+
+
+### Bug Fixes
+
+* **fingerprint:** do not throw on `MethodFingerprint.result` getter ([2f7e62e](https://github.com/revanced/revanced-patcher/commit/2f7e62ef65422f2c75ef8b09b9cd27076e172b30))
+
+
+### Performance Improvements
+
+* **fingerprint:** do not resolve already resolved fingerprints ([4bfd7eb](https://github.com/revanced/revanced-patcher/commit/4bfd7ebff8b6623b0da4a46d6048bed08c5070d4))
+
+## [4.4.1](https://github.com/revanced/revanced-patcher/compare/v4.4.0...v4.4.1) (2022-09-14)
+
+
+### Bug Fixes
+
+* compare any methods parameters ([#101](https://github.com/revanced/revanced-patcher/issues/101)) ([085a3a4](https://github.com/revanced/revanced-patcher/commit/085a3a479d7bd411dcb0492b283daca538c824a1))
+
+# [4.4.0](https://github.com/revanced/revanced-patcher/compare/v4.3.0...v4.4.0) (2022-09-09)
+
+
+### Features
+
+* add PathOption back ([172655b](https://github.com/revanced/revanced-patcher/commit/172655bde06efdb0955431b44d269e6a64fe317a))
+
+# [4.3.0](https://github.com/revanced/revanced-patcher/compare/v4.2.3...v4.3.0) (2022-09-09)
+
+
+### Features
+
+* improved Patch Options ([e722e3f](https://github.com/revanced/revanced-patcher/commit/e722e3f4f9dc64acf53595802a0a83cf46ee96b8))
+
+## [4.2.3](https://github.com/revanced/revanced-patcher/compare/v4.2.2...v4.2.3) (2022-09-08)
+
+
+### Bug Fixes
+
+* wrong value for iterator in PatchOptions ([e31ac1f](https://github.com/revanced/revanced-patcher/commit/e31ac1f132df56ba7d2f8446d289ae03ef28f67d))
+
+## [4.2.2](https://github.com/revanced/revanced-patcher/compare/v4.2.1...v4.2.2) (2022-09-08)
+
+
+### Bug Fixes
+
+* invalid type propagation in options ([b873228](https://github.com/revanced/revanced-patcher/commit/b873228ef0a9e6e431a4278c979caa5fcc508e0d)), closes [#98](https://github.com/revanced/revanced-patcher/issues/98)
+
+## [4.2.1](https://github.com/revanced/revanced-patcher/compare/v4.2.0...v4.2.1) (2022-09-08)
+
+
+### Bug Fixes
+
+* make patcher version public ([76c45dd](https://github.com/revanced/revanced-patcher/commit/76c45dd7c1ffdca57e30ae7109c9fe0e5768f877))
+
+# [4.2.0](https://github.com/revanced/revanced-patcher/compare/v4.1.5...v4.2.0) (2022-09-08)
+
+
+### Bug Fixes
+
+* remove repeatable from PatchDeprecated ([6e73631](https://github.com/revanced/revanced-patcher/commit/6e73631d4d21e5e862f07ed7517244f36394e5ca))
+
+
+### Features
+
+* SincePatcher annotation ([25f74dc](https://github.com/revanced/revanced-patcher/commit/25f74dc5e9ed1a09258345b920d4f5a0dd7da527))
+
+## [4.1.5](https://github.com/revanced/revanced-patcher/compare/v4.1.4...v4.1.5) (2022-09-08)
+
+
+### Bug Fixes
+
+* broken deprecation message ([62aa295](https://github.com/revanced/revanced-patcher/commit/62aa295e7372014238415af36d902a4e88e2acbc))
+
+## [4.1.4](https://github.com/revanced/revanced-patcher/compare/v4.1.3...v4.1.4) (2022-09-08)
+
+
+### Bug Fixes
+
+* handle option types and nulls properly ([aff4968](https://github.com/revanced/revanced-patcher/commit/aff4968e6f67239afa3b5c02cc133a17d9c3cbeb))
+
+## [4.1.3](https://github.com/revanced/revanced-patcher/compare/v4.1.2...v4.1.3) (2022-09-07)
+
+
+### Bug Fixes
+
+* only run list option check if not null ([4055939](https://github.com/revanced/revanced-patcher/commit/4055939c089e3c396c308c980215d93a1dea5954))
+
+## [4.1.2](https://github.com/revanced/revanced-patcher/compare/v4.1.1...v4.1.2) (2022-09-07)
+
+
+### Bug Fixes
+
+* invalid types for example options ([79f91e0](https://github.com/revanced/revanced-patcher/commit/79f91e0e5a6d99828f30aae55339ce0d897394c7))
+
+## [4.1.1](https://github.com/revanced/revanced-patcher/compare/v4.1.0...v4.1.1) (2022-09-07)
+
+
+### Bug Fixes
+
+* handle private companion objects ([ad3d332](https://github.com/revanced/revanced-patcher/commit/ad3d332e27d07e9d074bbaaf51af7eb2f9bfc7d5))
+
+# [4.1.0](https://github.com/revanced/revanced-patcher/compare/v4.0.0...v4.1.0) (2022-09-07)
+
+
+### Features
+
+* deprecation for patches ([80c2e80](https://github.com/revanced/revanced-patcher/commit/80c2e809251cdb04d2dd3b3bfdbb8844bdfa31fa))
+
+# [4.0.0](https://github.com/revanced/revanced-patcher/compare/v3.5.1...v4.0.0) (2022-09-07)
+
+
+### Code Refactoring
+
+* Improve Patch Options ([6b909c1](https://github.com/revanced/revanced-patcher/commit/6b909c1ee6b8c2ea08bbca059df755e2e5f31656))
+
+
+### BREAKING CHANGES
+
+* Options has been moved from Patch to a new interface called OptionsContainer and are now handled entirely different. Make sure to check the examples to understand how it works.
+
+## [3.5.1](https://github.com/revanced/revanced-patcher/compare/v3.5.0...v3.5.1) (2022-09-06)
+
+
+### Bug Fixes
+
+* add tests for PathOption ([d6308e1](https://github.com/revanced/revanced-patcher/commit/d6308e126c6217b098192c51b6e98bc85a8656bd))
+* PathOption should be open, not sealed ([a562e47](https://github.com/revanced/revanced-patcher/commit/a562e476c085841efbc7ee98b01d8e6bb18ed757))
+* typo in ListOption ([3921648](https://github.com/revanced/revanced-patcher/commit/392164862c83d6e76b2a2113d6f6d59fef0020d1))
+
+
+### Performance Improvements
+
+* make exception an object ([75d2be8](https://github.com/revanced/revanced-patcher/commit/75d2be88037c9cf5436ab69d92abea575409a865))
+
+# [3.5.0](https://github.com/revanced/revanced-patcher/compare/v3.4.1...v3.5.0) (2022-09-05)
+
+
+### Features
+
+* default value for `Package.versions` annotation parameter ([131dedd](https://github.com/revanced/revanced-patcher/commit/131dedd4b021fe1c3b0be49ccba4764b325770ea))
+
+## [3.4.1](https://github.com/revanced/revanced-patcher/compare/v3.4.0...v3.4.1) (2022-09-03)
+
+
+### Bug Fixes
+
+* remove default param from Package.versions ([4b81318](https://github.com/revanced/revanced-patcher/commit/4b813187107e85dc267dbc2d353884b2cc671cc4))
+
+# [3.4.0](https://github.com/revanced/revanced-patcher/compare/v3.3.3...v3.4.0) (2022-08-31)
+
+
+### Features
+
+* nullable parameters ([7882a8d](https://github.com/revanced/revanced-patcher/commit/7882a8d928cad8de8cfea711947fc02659549d20))
+
+## [3.3.3](https://github.com/revanced/revanced-patcher/compare/v3.3.2...v3.3.3) (2022-08-14)
+
+
+### Bug Fixes
+
+* show error message if cause is null ([f9da2ad](https://github.com/revanced/revanced-patcher/commit/f9da2ad531644617ad5a2cc6a1819d530e18ba22))
+
+## [3.3.2](https://github.com/revanced/revanced-patcher/compare/v3.3.1...v3.3.2) (2022-08-06)
+
+
+### Bug Fixes
+
+* close open files ([#75](https://github.com/revanced/revanced-patcher/issues/75)) ([123ad54](https://github.com/revanced/revanced-patcher/commit/123ad54c150bd04f4b8ef5c65334ea468ceb99cc))
+
+## [3.3.1](https://github.com/revanced/revanced-patcher/compare/v3.3.0...v3.3.1) (2022-08-03)
+
+
+### Bug Fixes
+
+* revert soft dependencies ([7b2d058](https://github.com/revanced/revanced-patcher/commit/7b2d058144b0718992d329731e2af7cc704e4370))
+
+# [3.3.0](https://github.com/revanced/revanced-patcher/compare/v3.2.1...v3.3.0) (2022-08-02)
+
+
+### Features
+
+* add getValue & setValue for PatchOption ([2572cd0](https://github.com/revanced/revanced-patcher/commit/2572cd04b5da4eeae738c8dde31493177edf0bf8))
+
+## [3.2.1](https://github.com/revanced/revanced-patcher/compare/v3.2.0...v3.2.1) (2022-08-02)
+
+
+### Bug Fixes
+
+* check if patch option requirement is met ([14a73bf](https://github.com/revanced/revanced-patcher/commit/14a73bfcafac36bce2b8466788d460edde7a14fd))
+
+# [3.2.0](https://github.com/revanced/revanced-patcher/compare/v3.1.0...v3.2.0) (2022-08-02)
+
+
+### Features
+
+* PatchOptions#nullify to nullify an option ([371f0c4](https://github.com/revanced/revanced-patcher/commit/371f0c4d0bf96e7f6db35085efccaed3000a096c))
+
+# [3.1.0](https://github.com/revanced/revanced-patcher/compare/v3.0.0...v3.1.0) (2022-08-02)
+
+
+### Features
+
+* validator for patch options ([4e2e772](https://github.com/revanced/revanced-patcher/commit/4e2e77238957d7732326cfe5e05145bf7dab5bfb))
+
+# [3.0.0](https://github.com/revanced/revanced-patcher/compare/v2.9.0...v3.0.0) (2022-08-02)
+
+
+### Features
+
+* registry for patch options ([2431785](https://github.com/revanced/revanced-patcher/commit/2431785d0e494d6271c6951eec9adfff9db95c17))
+
+
+### BREAKING CHANGES
+
+* Patch options now use the PatchOptions registry class instead of an Iterable. This change requires modifications to existing patches using this API.
+
+# [2.9.0](https://github.com/revanced/revanced-patcher/compare/v2.8.0...v2.9.0) (2022-08-02)
+
+
+### Bug Fixes
+
+* show error message instead of `null` ([8d95b14](https://github.com/revanced/revanced-patcher/commit/8d95b14f350b47ec029f35e776f6e627aaf5f607))
+
+
+### Features
+
+* exclusive mutable access to files ([814ce0b](https://github.com/revanced/revanced-patcher/commit/814ce0b9ae29725417c86b7d11b40d025724a426))
+
+# [2.8.0](https://github.com/revanced/revanced-patcher/compare/v2.7.0...v2.8.0) (2022-08-01)
+
+
+### Bug Fixes
+
+* remove requirement for solution [skip ci] ([#80](https://github.com/revanced/revanced-patcher/issues/80)) ([9a4d30e](https://github.com/revanced/revanced-patcher/commit/9a4d30e15234ef62844f035c58a1143674d4c12e))
+
+
+### Features
+
+* patch options ([#81](https://github.com/revanced/revanced-patcher/issues/81)) ([fbb09f3](https://github.com/revanced/revanced-patcher/commit/fbb09f38dce49adc7f63b71bdf2df2ef0b84db04))
+
+# [2.7.0](https://github.com/revanced/revanced-patcher/compare/v2.6.0...v2.7.0) (2022-08-01)
+
+
+### Features
+
+* `Closeable` patches ([bbd40bf](https://github.com/revanced/revanced-patcher/commit/bbd40bf2f6ff200705f2bcb272dd1680bb244e3f))
+
+# [2.6.0](https://github.com/revanced/revanced-patcher/compare/v2.5.2...v2.6.0) (2022-07-31)
+
+
+### Features
+
+* add Patch#dependsOn extension ([523f67b](https://github.com/revanced/revanced-patcher/commit/523f67b238646caaa9b7676a0e238ce82adbdda4))
+* Soft Dependencies for Patches ([8c12f8d](https://github.com/revanced/revanced-patcher/commit/8c12f8d488f939cc932e826aad0b20876ae165b7))
+
+## [2.5.2](https://github.com/revanced/revanced-patcher/compare/v2.5.1...v2.5.2) (2022-07-24)
+
+## [2.5.1](https://github.com/revanced/revanced-patcher/compare/v2.5.0...v2.5.1) (2022-07-17)
+
+
+### Bug Fixes
+
+* close stream when closing `DomFileEditor` ([77604d4](https://github.com/revanced/revanced-patcher/commit/77604d40785847b775155c0e75b663a3c7336aa3))
+
+# [2.5.0](https://github.com/revanced/revanced-patcher/compare/v2.4.0...v2.5.0) (2022-07-11)
+
+
+### Bug Fixes
+
+* missing additional items [skip ci] ([0ebab8b](https://github.com/revanced/revanced-patcher/commit/0ebab8bf598d993df6e340651205cba48f1ef725))
+
+
+### Features
+
+* feature request issue template ([1b39278](https://github.com/revanced/revanced-patcher/commit/1b39278b24ba2f964d93bd8ad2e28472ee036d90))
+* issue templates [skip ci] ([112bc99](https://github.com/revanced/revanced-patcher/commit/112bc998f4761a647cb9eab7454e35264fa96fd9))
+
+# [2.4.0](https://github.com/revanced/revanced-patcher/compare/v2.3.1...v2.4.0) (2022-07-09)
+
+
+### Features
+
+* Improve Smali Compiler ([6bfe571](https://github.com/revanced/revanced-patcher/commit/6bfe5716c38181bbe9476b5c6ad29526edb4e022))
+
+## [2.3.1](https://github.com/revanced/revanced-patcher/compare/v2.3.0...v2.3.1) (2022-07-07)
+
+
+### Bug Fixes
+
+* handle null properly ([#64](https://github.com/revanced/revanced-patcher/issues/64)) ([482af78](https://github.com/revanced/revanced-patcher/commit/482af78f2ba23b8003fc9961df5fde54d7295d5c))
+
+# [2.3.0](https://github.com/revanced/revanced-patcher/compare/v2.2.2...v2.3.0) (2022-07-05)
+
+
+### Features
+
+* nullability for `BytecodePatch` constructor ([#59](https://github.com/revanced/revanced-patcher/issues/59)) ([4ea030d](https://github.com/revanced/revanced-patcher/commit/4ea030d0a03f736bbecbd491317ba2167b18fe94))
+
+## [2.2.2](https://github.com/revanced/revanced-patcher/compare/v2.2.1...v2.2.2) (2022-07-04)
+
+
+### Bug Fixes
+
+* `MethodWalker` not accounting for all reference instructions ([48068cb](https://github.com/revanced/revanced-patcher/commit/48068cb3d79e283ff1cad9f3f78dc1d0fcd14f83))
+
+## [2.2.1](https://github.com/revanced/revanced-patcher/compare/v2.2.0...v2.2.1) (2022-07-03)
+
+
+### Bug Fixes
+
+* more useful error message ([4b2e323](https://github.com/revanced/revanced-patcher/commit/4b2e3230ec74fa3a57ae86067e5cb7cecbe45013))
+
+# [2.2.0](https://github.com/revanced/revanced-patcher/compare/v2.1.2...v2.2.0) (2022-07-02)
+
+
+### Bug Fixes
+
+* DomFileEditor opening in- and output streams on the same file ([83187c9](https://github.com/revanced/revanced-patcher/commit/83187c9edd7b088bc18960c5eb9a2042ca536b5f))
+
+
+### Features
+
+* remove deprecated functions ([ada5a03](https://github.com/revanced/revanced-patcher/commit/ada5a033de3cf94e7255ec2d522520f86431f001))
+* streams overload for `XmlFileHolder` ([6f72c4c](https://github.com/revanced/revanced-patcher/commit/6f72c4c4c051e48c8d03d2a7b2cfc1c53028ed86))
+
+# [2.2.0-dev.3](https://github.com/revanced/revanced-patcher/compare/v2.2.0-dev.2...v2.2.0-dev.3) (2022-07-02)
+
+
+### Bug Fixes
+
+* DomFileEditor opening in- and output streams on the same file ([83187c9](https://github.com/revanced/revanced-patcher/commit/83187c9edd7b088bc18960c5eb9a2042ca536b5f))
+
+# [2.2.0-dev.2](https://github.com/revanced/revanced-patcher/compare/v2.2.0-dev.1...v2.2.0-dev.2) (2022-07-02)
+
+
+### Features
+
+* streams overload for `XmlFileHolder` ([6f72c4c](https://github.com/revanced/revanced-patcher/commit/6f72c4c4c051e48c8d03d2a7b2cfc1c53028ed86))
+
 # [2.2.0-dev.1](https://github.com/revanced/revanced-patcher/compare/v2.1.2...v2.2.0-dev.1) (2022-07-02)
 
 

README.md

@@ -1 +1,3 @@
-# Patcher
+# 💉 ReVanced Patcher
+
+ReVanced Patcher used to patch Android applications.

build.gradle.kts

@@ -1,6 +1,5 @@
 plugins {
-    kotlin("jvm") version "1.7.0"
-    java
+    kotlin("jvm") version "1.8.20"
     `maven-publish`
 }
 
@@ -22,11 +21,12 @@ repositories {
 
 dependencies {
     implementation("xpp3:xpp3:1.1.4c")
-    implementation("org.smali:smali:2.5.2")
-    implementation("app.revanced:multidexlib2:2.5.2.r2")
-    implementation("org.apktool:apktool-lib:2.6.9-SNAPSHOT")
+    implementation("app.revanced:smali:2.5.3-a3836654")
+    implementation("app.revanced:multidexlib2:2.5.3-a3836654")
+    implementation("app.revanced:apktool-lib:2.8.3")
 
-    testImplementation(kotlin("test"))
+    implementation("org.jetbrains.kotlin:kotlin-reflect:1.8.22")
+    testImplementation("org.jetbrains.kotlin:kotlin-test:1.8.20-RC")
 }
 
 tasks {
@@ -36,12 +36,19 @@ tasks {
             events("PASSED", "SKIPPED", "FAILED")
         }
     }
+    processResources {
+        expand("projectVersion" to project.version)
+    }
 }
 
 java {
     withSourcesJar()
 }
 
+kotlin {
+    jvmToolchain(11)
+}
+
 publishing {
     repositories {
         if (System.getenv("GITHUB_ACTOR") != null)

gradle.properties

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

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-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>,
-#           <EFBFBD>${var#prefix}<EFBFBD>, <EFBFBD>${var%suffix}<EFBFBD>, and <EFBFBD>$( cmd )<EFBFBD>;
-#         * compound commands having a testable exit status, especially <EFBFBD>case<EFBFBD>;
-#         * various built-in commands including <EFBFBD>command<EFBFBD>, <EFBFBD>set<EFBFBD>, and <EFBFBD>ulimit<EFBFBD>.
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * 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
-
-APP_NAME="Gradle"
+# This is normally unused
+# shellcheck disable=SC2034
 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"'
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # 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
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+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

package.json

@@ -0,0 +1,9 @@
+{
+  "devDependencies": {
+    "@saithodev/semantic-release-backmerge": "^3.1.0",
+    "@semantic-release/changelog": "^6.0.2",
+    "@semantic-release/git": "^10.0.1",
+    "gradle-semantic-release-plugin": "^1.7.6",
+    "semantic-release": "^20.1.0"
+  }
+}

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

@@ -1,40 +1,36 @@
 package app.revanced.patcher
 
-import app.revanced.patcher.data.Data
-import app.revanced.patcher.data.PackageMetadata
-import app.revanced.patcher.data.impl.findIndexed
+import app.revanced.patcher.data.Context
 import app.revanced.patcher.extensions.PatchExtensions.dependencies
 import app.revanced.patcher.extensions.PatchExtensions.patchName
-import app.revanced.patcher.extensions.nullOutputStream
-import app.revanced.patcher.fingerprint.method.utils.MethodFingerprintUtils.resolve
-import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.PatchResult
-import app.revanced.patcher.patch.PatchResultError
-import app.revanced.patcher.patch.PatchResultSuccess
-import app.revanced.patcher.patch.impl.BytecodePatch
-import app.revanced.patcher.patch.impl.ResourcePatch
-import app.revanced.patcher.util.ListBackedSet
-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 app.revanced.patcher.extensions.PatchExtensions.requiresIntegrations
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolveUsingLookupMap
+import app.revanced.patcher.patch.*
+import brut.androlib.AaptInvoker
+import brut.androlib.ApkDecoder
+import brut.androlib.Config
+import brut.androlib.res.Framework
+import brut.androlib.res.ResourcesDecoder
+import brut.androlib.res.decoder.AndroidManifestResourceParser
 import brut.androlib.res.decoder.ResAttrDecoder
 import brut.androlib.res.decoder.XmlPullStreamDecoder
+import brut.androlib.res.util.ExtMXSerializer
+import brut.androlib.res.util.ExtXmlSerializer
 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.ClassDef
 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.nio.file.Files
 
-val NAMER = BasicDexFileNamer()
+internal val NAMER = BasicDexFileNamer()
 
 /**
  * The ReVanced Patcher.
@@ -43,114 +39,42 @@ val NAMER = BasicDexFileNamer()
 class Patcher(private val options: PatcherOptions) {
     private val logger = options.logger
     private val opcodes: Opcodes
+    private var resourceDecodingMode = ResourceDecodingMode.MANIFEST_ONLY
+    private var mergeIntegrations = false
+    val context: PatcherContext
 
-    val data: PatcherData
+    private val config = Config.getDefaultConfig().apply {
+        aaptPath = options.aaptPath
+        frameworkDirectory = options.frameworkDirectory
+    }
 
     init {
-        val extInputFile = ExtFile(options.inputFile)
-        val outDir = File(options.resourceCacheDirectory)
-        if (outDir.exists()) {
-            logger.info("Deleting existing resource cache directory")
-            outDir.deleteRecursively()
-        }
-        outDir.mkdirs()
-
-        val androlib = Androlib(BuildOptions().also { it.setBuildOptions(options) })
-        val resourceTable = androlib.getResTable(extInputFile, true)
-
-        val packageMetadata = PackageMetadata()
-
-        if (options.patchResources) {
-            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
-            packageMetadata.metaInfo.usesFramework = UsesFramework().also { framework ->
-                framework.ids = resourceTable.listFramePackages().map { it.id }.sorted()
-            }
-
-            packageMetadata.metaInfo.doNotCompress = buildList {
-                androlib.recordUncompressedFiles(extInputFile, this)
-            }
-
-        } else {
-            logger.info("Only decoding AndroidManifest.xml because resource patching is disabled")
-
-            // 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"), nullOutputStream
-            )
-        }
-
-        packageMetadata.packageName = resourceTable.currentResPackage.name
-        packageMetadata.packageVersion = resourceTable.versionInfo.versionName
-        packageMetadata.metaInfo.versionInfo = resourceTable.versionInfo
-        packageMetadata.metaInfo.sdkInfo = resourceTable.sdkInfo
-
         logger.info("Reading dex files")
-
         // read dex files
         val dexFile = MultiDexIO.readDexFile(true, options.inputFile, NAMER, null, null)
         // get the opcodes
         opcodes = dexFile.opcodes
+        // finally create patcher context
+        context = PatcherContext(dexFile.classes.toMutableList(), File(options.resourceCacheDirectory))
 
-        // finally create patcher data
-        data = PatcherData(
-            dexFile.classes.toMutableList(), options.resourceCacheDirectory, packageMetadata
-        )
+        // decode manifest file
+        decodeResources(ResourceDecodingMode.MANIFEST_ONLY)
     }
 
     /**
-     * Add additional dex file container to the patcher.
-     * @param files The dex file containers to add to the patcher.
-     * @param allowedOverwrites A list of class types that are allowed to be overwritten.
-     * @param throwOnDuplicates If this is set to true, the patcher will throw an exception if a duplicate class has been found.
+     * Add integrations to be merged by the patcher.
+     * 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 addFiles(
-        files: List<File>,
-        allowedOverwrites: Iterable<String> = emptyList(),
-        throwOnDuplicates: Boolean = false,
+    fun addIntegrations(
+        integrations: List<File>,
         callback: (File) -> Unit
     ) {
-        for (file in files) {
-            var modified = false
-            for (classDef in MultiDexIO.readDexFile(true, file, NAMER, null, null).classes) {
-                val type = classDef.type
-
-                val existingClass = data.bytecodeData.classes.internalClasses.findIndexed { it.type == type }
-                if (existingClass == null) {
-                    if (throwOnDuplicates) throw Exception("Class $type has already been added to the patcher")
-
-                    logger.trace("Merging $type")
-                    data.bytecodeData.classes.internalClasses.add(classDef)
-                    modified = true
-
-                    continue
-                }
-
-                if (!allowedOverwrites.contains(type)) continue
-
-                logger.trace("Overwriting $type")
-
-                val index = existingClass.second
-                data.bytecodeData.classes.internalClasses[index] = classDef
-                modified = true
-            }
-            if (modified) callback(file)
+        context.integrations.apply integrations@{
+            add(integrations)
+            this@integrations.callback = callback
         }
     }
 
@@ -158,61 +82,46 @@ class Patcher(private val options: PatcherOptions) {
      * Save the patched dex file.
      */
     fun save(): PatcherResult {
-        val packageMetadata = data.packageMetadata
-        val metaInfo = packageMetadata.metaInfo
         var resourceFile: File? = null
 
-        if (options.patchResources) {
-            val cacheDirectory = ExtFile(options.resourceCacheDirectory)
+        when (resourceDecodingMode) {
+            ResourceDecodingMode.FULL -> {
+                logger.info("Compiling resources")
 
-            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
+                val cacheDirectory = ExtFile(options.resourceCacheDirectory)
+                val aaptFile = cacheDirectory.resolve("aapt_temp_file").also {
+                    Files.deleteIfExists(it.toPath())
+                }.also { resourceFile = it }
+
+                try {
+                    AaptInvoker(
+                        config,
+                        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(config).getFrameworkApk(id, usesFramework.tag)
+                            }.toTypedArray()
+                        }
+                    )
+                } finally {
+                    cacheDirectory.close()
                 }
-
-                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
+            else -> logger.info("Not compiling resources because resource patching is not required")
         }
 
         logger.trace("Creating new dex file")
         val newDexFile = object : DexFile {
-            override fun getClasses(): Set<ClassDef> {
-                data.bytecodeData.classes.applyProxies()
-                return ListBackedSet(data.bytecodeData.classes.internalClasses)
-            }
-
-            override fun getOpcodes(): Opcodes {
-                return this@Patcher.opcodes
-            }
+            override fun getClasses() = context.bytecodeContext.classes.also { it.replaceClasses() }
+            override fun getOpcodes() = this@Patcher.opcodes
         }
 
         // write modified dex files
@@ -226,7 +135,9 @@ class Patcher(private val options: PatcherOptions) {
         return PatcherResult(
             dexFiles.map {
                 app.revanced.patcher.util.dex.DexFile(it.key, it.value.readAt(0))
-            }, metaInfo.doNotCompress.toList(), resourceFile
+            },
+            context.packageMetadata.apkInfo.doNotCompress?.toList(),
+            resourceFile
         )
     }
 
@@ -234,99 +145,251 @@ class Patcher(private val options: PatcherOptions) {
      * Add [Patch]es to the patcher.
      * @param patches [Patch]es The patches to add.
      */
-    fun addPatches(patches: Iterable<Class<out Patch<Data>>>) {
-        data.patches.addAll(patches)
+    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 =
+            predicate(this) || dependencies?.any { it.java.anyRecursively(predicate) } == true
+
+
+        // Determine if resource patching is required.
+        for (patch in patches) {
+            if (patch.anyRecursively { ResourcePatch::class.java.isAssignableFrom(it) }) {
+                resourceDecodingMode = ResourceDecodingMode.FULL
+                break
+            }
+        }
+
+        // Determine if merging integrations is required.
+        for (patch in patches) {
+            if (patch.anyRecursively { it.requiresIntegrations }) {
+                mergeIntegrations = true
+                break
+            }
+        }
+
+        context.patches.addAll(patches)
     }
 
     /**
-     * Apply a [patch] and its dependencies recursively.
-     * @param patch The [patch] to apply.
-     * @param appliedPatches A map of [patch]es paired to a boolean indicating their success, to prevent infinite recursion.
-     * @return The result of executing the [patch].
+     * Decode resources for the patcher.
+     *
+     * @param mode The [ResourceDecodingMode] to use when decoding.
      */
-    private fun applyPatch(
-        patch: Class<out Patch<Data>>,
-        appliedPatches: MutableMap<String, Boolean>
-    ): PatchResult {
-        val patchName = patch.patchName
+    private fun decodeResources(mode: ResourceDecodingMode) {
+        val extInputFile = ExtFile(options.inputFile)
+        try {
+            val resourcesDecoder = ResourcesDecoder(config, extInputFile)
 
-        // if the patch has already applied silently skip it
-        if (appliedPatches.contains(patchName)) {
-            if (!appliedPatches[patchName]!!)
-                return PatchResultError("'$patchName' did not succeed previously")
+            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")
+                    }
 
-            logger.trace("Skipping '$patchName' because it has already been applied")
+                    outDir.mkdirs()
 
-            return PatchResultSuccess()
-        }
+                    logger.info("Decoding resources")
 
-        // recursively apply all dependency patches
-        patch.dependencies?.forEach {
-            val patchDependency = it.java
+                    resourcesDecoder.decodeManifest(outDir)
+                    resourcesDecoder.decodeResources(outDir)
 
-            val result = applyPatch(patchDependency, appliedPatches)
+                    context.packageMetadata.also {
+                        it.apkInfo = resourcesDecoder.apkInfo
+                    }.apkInfo.doNotCompress = ApkDecoder(config, extInputFile).recordUncompressedFiles(
+                        context.packageMetadata.apkInfo, resourcesDecoder.resFileMapping
+                    )
+                }
+                ResourceDecodingMode.MANIFEST_ONLY -> {
+                    logger.info("Decoding AndroidManifest.xml only, because resources are not needed")
 
-            if (result.isSuccess()) return@forEach
+                    // Instead of using resourceDecoder.decodeManifest which decodes the whole file
+                    // use the XmlPullStreamDecoder in order to get necessary information from the manifest
+                    // used below.
+                    XmlPullStreamDecoder(AndroidManifestResourceParser().apply {
+                        attrDecoder = ResAttrDecoder().apply { this.resTable = resourcesDecoder.resTable }
+                    }, ExtMXSerializer().apply {
+                        setProperty(
+                            ExtXmlSerializer.PROPERTY_SERIALIZER_INDENTATION, "    "
+                        )
+                        setProperty(
+                            ExtXmlSerializer.PROPERTY_SERIALIZER_LINE_SEPARATOR,
+                            System.getProperty("line.separator")
+                        )
+                        setProperty(
+                            ExtXmlSerializer.PROPERTY_DEFAULT_ENCODING,
+                                "utf-8"
+                            )
+                            setDisabledAttrEscape(true)
+                        }
+                    ).decodeManifest(
+                        extInputFile.directory.getFileInput("AndroidManifest.xml"),
+                        // Older Android versions do not support OutputStream.nullOutputStream()
+                        object : OutputStream() { override fun write(b: Int) { /* do nothing */ } }
+                    )
+                }
+            }
 
-            val errorMessage = result.error()!!.message
-            return PatchResultError("'$patchName' depends on '${patchDependency.patchName}' but the following error was raised: $errorMessage")
-        }
+            // Get the package name and version from the manifest using the XmlPullStreamDecoder.
+            // XmlPullStreamDecoder.decodeManifest() sets metadata.apkInfo.
+            context.packageMetadata.let { metadata ->
+                metadata.apkInfo = resourcesDecoder.apkInfo
 
-        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) {
-            data.resourceData
-        } else {
-            val bytecodeData = data.bytecodeData
-            (patchInstance as BytecodePatch).fingerprints.resolve(bytecodeData, bytecodeData.classes.internalClasses)
-            bytecodeData
-        }
-
-        logger.trace("Executing '$patchName' of type: ${if (isResourcePatch) "resource" else "bytecode"}")
-
-        return try {
-            val result = patchInstance.execute(data)
-            appliedPatches[patchName] = result.isSuccess()
-            result
-        } catch (e: Exception) {
-            appliedPatches[patchName] = false
-            PatchResultError(e)
+                metadata.packageName = resourcesDecoder.resTable.currentResPackage.name
+                resourcesDecoder.apkInfo.versionInfo.let {
+                    metadata.packageVersion = it.versionName ?: it.versionCode
+                }
+            }
+        } finally {
+            extInputFile.close()
         }
     }
 
     /**
-     * Apply patches loaded into the patcher.
+     * Execute patches added the patcher.
+     *
      * @param stopOnError If true, the patches will stop on the first error.
      * @return A pair of the name of the [Patch] and its [PatchResult].
      */
-    fun applyPatches(stopOnError: Boolean = false) = sequence {
-        logger.trace("Applying all patches")
-        val appliedPatches = mutableMapOf<String, Boolean>() // first is success, second is name
+    fun executePatches(stopOnError: Boolean = false): Sequence<Pair<String, Result<PatchResultSuccess>>> {
+        /**
+         * 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.
+         * @return The result of executing the [Patch].
+         */
+        fun executePatch(
+            patchClass: Class<out Patch<Context>>,
+            executedPatches: LinkedHashMap<String, ExecutedPatch>
+        ): PatchResult {
+            val patchName = patchClass.patchName
 
-        for (patch in data.patches) {
-            val patchResult = applyPatch(patch, appliedPatches)
+            // if the patch has already applied silently skip it
+            if (executedPatches.contains(patchName)) {
+                if (!executedPatches[patchName]!!.success)
+                    return PatchResultError("'$patchName' did not succeed previously")
 
-            val result = if (patchResult.isSuccess()) {
-                Result.success(patchResult.success()!!)
-            } else {
-                Result.failure(patchResult.error()!!)
+                logger.trace("Skipping '$patchName' because it has already been applied")
+
+                return PatchResultSuccess()
             }
 
-            yield(patch.patchName to result)
-            if (stopOnError && patchResult.isError()) break
+            // 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(
+                    "'$patchName' depends on '${dependency.patchName}' but the following error was raised: " +
+                            result.error()!!.let { it.cause?.stackTraceToString() ?: it.message }
+                )
+            }
+
+            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?.resolveUsingLookupMap(context)
+                }
+            }
+
+            logger.trace("Executing '$patchName' of type: ${if (isResourcePatch) "resource" else "bytecode"}")
+
+            return try {
+                patchInstance.execute(patchContext).also {
+                    executedPatches[patchName] = ExecutedPatch(patchInstance, it.isSuccess())
+                }
+            } catch (e: Exception) {
+                PatchResultError(e).also {
+                    executedPatches[patchName] = ExecutedPatch(patchInstance, false)
+                }
+            }
         }
+
+        return sequence {
+            if (mergeIntegrations) context.integrations.merge(logger)
+
+            logger.trace("Initialize lookup maps for method MethodFingerprint resolution")
+
+            MethodFingerprint.initializeFingerprintResolutionLookupMaps(context.bytecodeContext)
+
+            // prevent from decoding the manifest twice if it is not needed
+            if (resourceDecodingMode == ResourceDecodingMode.FULL) decodeResources(ResourceDecodingMode.FULL)
+
+            logger.info("Executing patches")
+
+            val executedPatches = LinkedHashMap<String, ExecutedPatch>() // first is name
+
+            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
+                //  because the Closeable is closed after all patches are executed.
+                yield(patch.patchName to result)
+
+                if (stopOnError && patchResult.isError()) return@sequence
+            }
+
+            executedPatches.values
+                .filter(ExecutedPatch::success)
+                .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
+                    }
+                }
+
+            MethodFingerprint.clearFingerprintResolutionLookupMaps()
+        }
+    }
+
+    /**
+     * The type of decoding the resources.
+     */
+    private enum class ResourceDecodingMode {
+        /**
+         * Decode all resources.
+         */
+        FULL,
+
+        /**
+         * Decode the manifest file only.
+         */
+        MANIFEST_ONLY,
     }
 }
 
-private fun BuildOptions.setBuildOptions(options: PatcherOptions) {
-    this.aaptPath = options.aaptPath
-    this.useAapt2 = true
-    this.frameworkFolderLocation = options.frameworkFolderLocation
-}
+/**
+ * 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

@@ -0,0 +1,64 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.data.*
+import app.revanced.patcher.logging.Logger
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.util.ClassMerger.merge
+import org.jf.dexlib2.iface.ClassDef
+import java.io.File
+
+data class PatcherContext(
+    val classes: MutableList<ClassDef>,
+    val resourceCacheDirectory: File,
+) {
+    val packageMetadata = PackageMetadata()
+    internal val patches = mutableListOf<Class<out Patch<Context>>>()
+    internal val integrations = Integrations(this)
+    internal val bytecodeContext = BytecodeContext(classes)
+    internal val resourceContext = ResourceContext(resourceCacheDirectory)
+
+    internal class Integrations(val context: PatcherContext) {
+        var callback: ((File) -> Unit)? = null
+        private val integrations: MutableList<File> = mutableListOf()
+
+        fun add(integrations: List<File>) = this@Integrations.integrations.addAll(integrations)
+
+        /**
+         * Merge integrations.
+         * @param logger A logger.
+         */
+        fun merge(logger: Logger) {
+            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/PatcherData.kt

@@ -1,19 +0,0 @@
-package app.revanced.patcher
-
-import app.revanced.patcher.data.Data
-import app.revanced.patcher.data.PackageMetadata
-import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.data.impl.ResourceData
-import app.revanced.patcher.patch.Patch
-import org.jf.dexlib2.iface.ClassDef
-import java.io.File
-
-data class PatcherData(
-    internal val internalClasses: MutableList<ClassDef>,
-    internal val resourceCacheDirectory: String,
-    val packageMetadata: PackageMetadata
-) {
-    internal val patches = mutableListOf<Class<out Patch<Data>>>()
-    internal val bytecodeData = BytecodeData(internalClasses)
-    internal val resourceData = ResourceData(File(resourceCacheDirectory))
-}

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

@@ -8,16 +8,14 @@ import java.io.File
  * Options for the [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 aaptPath Optional path to a custom aapt binary.
- * @param frameworkFolderLocation Optional path to a custom framework folder.
+ * @param frameworkDirectory Optional path to a custom framework directory.
  * @param logger Custom logger implementation for the [Patcher].
  */
 data class PatcherOptions(
     internal val inputFile: File,
     internal val resourceCacheDirectory: String,
-    internal val patchResources: Boolean = false,
-    internal val aaptPath: String = "",
-    internal val frameworkFolderLocation: String? = null,
+    internal val aaptPath: String? = null,
+    internal val frameworkDirectory: String? = null,
     internal val logger: Logger = NopLogger
 )

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

@@ -1,15 +1,12 @@
 package app.revanced.patcher.annotation
 
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 import app.revanced.patcher.patch.Patch
 
 /**
- * Annotation to constrain a [Patch] or [MethodFingerprint] to compatible packages.
- * @param compatiblePackages A list of packages a [Patch] or [MethodFingerprint] is compatible with.
+ * Annotation to constrain a [Patch] to compatible packages.
+ * @param compatiblePackages A list of packages a [Patch] is compatible with.
  */
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
 annotation class Compatibility(
     val compatiblePackages: Array<Package>,
 )
@@ -17,12 +14,10 @@ annotation class Compatibility(
 /**
  * Annotation to represent packages a patch can be compatible with.
  * @param name The package identifier name.
- * @param versions The versions of the package the [Patch] or [MethodFingerprint]is compatible with.
+ * @param versions The versions of the package the [Patch] is compatible with.
  */
 @Target()
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
 annotation class Package(
     val name: String,
-    val versions: Array<String>
-)
+    val versions: Array<String> = [],
+)

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

@@ -1,38 +1,32 @@
 package app.revanced.patcher.annotation
 
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 import app.revanced.patcher.patch.Patch
 
 /**
- * Annotation to name a [Patch] or [MethodFingerprint].
- * @param name A suggestive name for the [Patch] or [MethodFingerprint].
+ * Annotation to name a [Patch].
+ * @param name A suggestive name for the [Patch].
  */
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
 annotation class Name(
     val name: String,
 )
 
 /**
- * Annotation to describe a [Patch] or [MethodFingerprint].
- * @param description A description for the [Patch] or [MethodFingerprint].
+ * Annotation to describe a [Patch].
+ * @param description A description for the [Patch].
  */
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
 annotation class Description(
     val description: String,
 )
 
 
 /**
- * Annotation to version a [Patch] or [MethodFingerprint].
- * @param version The version of a [Patch] or [MethodFingerprint].
+ * Annotation to version a [Patch].
+ * @param version The version of a [Patch].
  */
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
+@Deprecated("This annotation is deprecated and will be removed in a future release.")
 annotation class Version(
     val version: String,
 )

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

@@ -0,0 +1,170 @@
+package app.revanced.patcher.data
+
+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
+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].
+ */
+
+sealed interface Context
+
+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/Data.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.data
-
-import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.data.impl.ResourceData
-
-/**
- * Constraint interface for [BytecodeData] and [ResourceData]
- */
-interface Data

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

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

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

@@ -1,69 +0,0 @@
-package app.revanced.patcher.data.impl
-
-import app.revanced.patcher.data.Data
-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(
-    internalClasses: MutableList<ClassDef>
-) : Data {
-    val classes = ProxyBackedClassList(internalClasses)
-
-    /**
-     * 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
-    }
-}
-
-internal class MethodNotFoundException(s: String) : Exception(s)
-
-internal inline fun <reified T> Iterable<T>.find(predicate: (T) -> Boolean): T? {
-    for (element in this) {
-        if (predicate(element)) {
-            return element
-        }
-    }
-    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)
-}
-
-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
-}

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

@@ -1,28 +0,0 @@
-package app.revanced.patcher.data.impl
-
-import app.revanced.patcher.data.Data
-import org.w3c.dom.Document
-import java.io.Closeable
-import java.io.File
-import javax.xml.parsers.DocumentBuilderFactory
-import javax.xml.transform.TransformerFactory
-import javax.xml.transform.dom.DOMSource
-import javax.xml.transform.stream.StreamResult
-
-class ResourceData(private val resourceCacheDirectory: File) : Data, Iterable<File> {
-    operator fun get(path: String) = resourceCacheDirectory.resolve(path)
-    val xmlEditor = XmlFileHolder()
-    override fun iterator() = resourceCacheDirectory.walkTopDown().iterator()
-
-    inner class XmlFileHolder {
-        operator fun get(path: String) = DomFileEditor(this@ResourceData[path])
-    }
-}
-
-class DomFileEditor internal constructor(private val domFile: File) : Closeable {
-    val file: Document = DocumentBuilderFactory.newInstance().newDocumentBuilder()
-        .parse(domFile).also(Document::normalize)
-
-    override fun close() = TransformerFactory.newInstance().newTransformer()
-        .transform(DOMSource(file), StreamResult(domFile.outputStream()))
-}

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

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

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

@@ -1,178 +1,33 @@
 package app.revanced.patcher.extensions
 
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
-import app.revanced.patcher.util.smali.toInstruction
-import app.revanced.patcher.util.smali.toInstructions
 import org.jf.dexlib2.AccessFlags
-import org.jf.dexlib2.builder.BuilderInstruction
-import org.jf.dexlib2.builder.MutableMethodImplementation
-import org.jf.dexlib2.iface.Method
-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
-import java.io.OutputStream
 
-infix fun AccessFlags.or(other: AccessFlags) = this.value or other.value
+/**
+ * Create a label for the instruction at given index.
+ *
+ * @param index The index to create the label for the instruction at.
+ * @return The label.
+ */
+fun MutableMethod.newLabel(index: Int) = implementation!!.newLabelForIndex(index)
+
+/**
+ * Perform a bitwise OR operation between two [AccessFlags].
+ *
+ * @param other The other [AccessFlags] to perform the operation with.
+ */
+infix fun AccessFlags.or(other: AccessFlags) = value or other.value
+
+/**
+ * Perform a bitwise OR operation between an [AccessFlags] and an [Int].
+ *
+ * @param other The [Int] to perform the operation with.
+ */
 infix fun Int.or(other: AccessFlags) = this or other.value
 
-fun MutableMethodImplementation.addInstructions(index: Int, instructions: List<BuilderInstruction>) {
-    for (i in instructions.lastIndex downTo 0) {
-        this.addInstruction(index, instructions[i])
-    }
-}
-
-fun MutableMethodImplementation.replaceInstructions(index: Int, instructions: List<BuilderInstruction>) {
-    for (i in instructions.lastIndex downTo 0) {
-        this.replaceInstruction(index + i, instructions[i])
-    }
-}
-
-fun MutableMethodImplementation.removeInstructions(index: Int, count: Int) {
-    for (i in count downTo 0) {
-        this.removeInstruction(index + i)
-    }
-}
-
 /**
- * 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.
+ * Perform a bitwise OR operation between an [Int] and an [AccessFlags].
+ *
+ * @param other The [AccessFlags] to perform the operation with.
  */
-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.
- * This may be a positive or negative number.
- * @return The **immutable** cloned method. Call [toMutable] or [cloneMutable] to get a **mutable** copy.
- */
-internal fun Method.clone(
-    registerCount: Int = 0,
-): ImmutableMethod {
-    val clonedImplementation = implementation?.let {
-        ImmutableMethodImplementation(
-            it.registerCount + registerCount,
-            it.instructions,
-            it.tryBlocks,
-            it.debugItems,
-        )
-    }
-    return ImmutableMethod(
-        returnType,
-        name,
-        parameters,
-        returnType,
-        accessFlags,
-        annotations,
-        hiddenApiRestrictions,
-        clonedImplementation
-    )
-}
-
-/**
- * Add a smali instruction to the method.
- * @param instruction The smali instruction to add.
- */
-fun MutableMethod.addInstruction(instruction: String) =
-    this.implementation!!.addInstruction(instruction.toInstruction(this))
-
-/**
- * Add a smali instruction to the method.
- * @param index The index to insert the instruction at.
- * @param instruction The smali instruction to add.
- */
-fun MutableMethod.addInstruction(index: Int, instruction: String) =
-    this.implementation!!.addInstruction(index, instruction.toInstruction(this))
-
-/**
- * Replace a smali instruction within the method.
- * @param index The index to replace the instruction at.
- * @param instruction The smali instruction to place.
- */
-fun MutableMethod.replaceInstruction(index: Int, instruction: String) =
-    this.implementation!!.replaceInstruction(index, instruction.toInstruction(this))
-
-/**
- * Remove a smali instruction within the method.
- * @param index The index to delete the instruction at.
- */
-fun MutableMethod.removeInstruction(index: Int) =
-    this.implementation!!.removeInstruction(index)
-
-/**
- * Add smali instructions to the method.
- * @param index The index to insert the instructions at.
- * @param instructions The smali instructions to add.
- */
-fun MutableMethod.addInstructions(index: Int, instructions: String) =
-    this.implementation!!.addInstructions(index, instructions.toInstructions(this))
-
-/**
- * Replace smali instructions within the method.
- * @param index The index to replace the instructions at.
- * @param instructions The smali instructions to place.
- */
-fun MutableMethod.replaceInstructions(index: Int, instructions: String) =
-    this.implementation!!.replaceInstructions(index, instructions.toInstructions(this))
-
-/**
- * Remove smali instructions from the method.
- * @param index The index to remove the instructions at.
- * @param count The amount of instructions to remove.
- */
-fun MutableMethod.removeInstructions(index: Int, count: Int) =
-    this.implementation!!.removeInstructions(index, count)
-
-/**
- * Clones the method.
- * @param registerCount This parameter allows you to change the register count of the method.
- * This may be a positive or negative number.
- * @return The **mutable** cloned method. Call [clone] to get an **immutable** copy.
- */
-internal fun Method.cloneMutable(
-    registerCount: Int = 0,
-) = clone(registerCount).toMutable()
-
-// FIXME: also check the order of parameters as different order equals different method overload
-internal fun parametersEqual(
-    parameters1: Iterable<CharSequence>,
-    parameters2: Iterable<CharSequence>
-): Boolean {
-    return parameters1.count() == parameters2.count() && parameters1.all { parameter ->
-        parameters2.any {
-            it.startsWith(
-                parameter
-            )
-        }
-    }
-}
-
-internal val nullOutputStream: OutputStream =
-    object : OutputStream() {
-        override fun write(b: Int) {}
-    }
-
-/**
- * Should be used to parse a list of parameters represented by their first letter,
- * or in the case of arrays prefixed with an unspecified amount of '[' character.
- */
-internal fun String.parseParameters(): List<String> {
-    val parameters = mutableListOf<String>()
-    var parameter = ""
-    for (char in this.toCharArray()) {
-        parameter += char
-        if (char == '[') continue
-
-        parameters.add(parameter)
-        parameter = ""
-    }
-    return parameters
-}
+infix fun AccessFlags.or(other: Int) = value or other

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

@@ -0,0 +1,331 @@
+package app.revanced.patcher.extensions
+
+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 org.jf.dexlib2.builder.BuilderOffsetInstruction
+import org.jf.dexlib2.builder.Label
+import org.jf.dexlib2.builder.MutableMethodImplementation
+import org.jf.dexlib2.builder.instruction.*
+import org.jf.dexlib2.iface.instruction.Instruction
+
+object InstructionExtensions {
+
+    /**
+     * Add instructions to a method at the given index.
+     *
+     * @param index The index to add the instructions at.
+     * @param instructions The instructions to add.
+     */
+    fun MutableMethodImplementation.addInstructions(
+        index: Int,
+        instructions: List<BuilderInstruction>
+    ) =
+        instructions.asReversed().forEach { addInstruction(index, it) }
+
+    /**
+     * Add instructions to a method.
+     * The instructions will be added at the end of the method.
+     *
+     * @param instructions The instructions to add.
+     */
+    fun MutableMethodImplementation.addInstructions(instructions: List<BuilderInstruction>) =
+        instructions.forEach { this.addInstruction(it) }
+
+    /**
+     * Remove instructions from a method at the given index.
+     *
+     * @param index The index to remove the instructions at.
+     * @param count The amount of instructions to remove.
+     */
+    fun MutableMethodImplementation.removeInstructions(index: Int, count: Int) = repeat(count) {
+        removeInstruction(index)
+    }
+
+    /**
+     * Remove the first instructions from a method.
+     *
+     * @param count The amount of instructions to remove.
+     */
+    fun MutableMethodImplementation.removeInstructions(count: Int) = removeInstructions(0, count)
+
+    /**
+     * Replace instructions at the given index with the given instructions.
+     * The amount of instructions to replace is the amount of instructions in the given list.
+     *
+     * @param index The index to replace the instructions at.
+     * @param instructions The instructions to replace the instructions with.
+     */
+    fun MutableMethodImplementation.replaceInstructions(index: Int, instructions: List<BuilderInstruction>) {
+        // Remove the instructions at the given index.
+        removeInstructions(index, instructions.size)
+
+        // Add the instructions at the given index.
+        addInstructions(index, instructions)
+    }
+
+    /**
+     * Add an instruction to a method at the given index.
+     *
+     * @param index The index to add the instruction at.
+     * @param instruction The instruction to add.
+     */
+    fun MutableMethod.addInstruction(index: Int, instruction: BuilderInstruction) =
+        implementation!!.addInstruction(index, instruction)
+
+    /**
+     * Add an instruction to a method.
+     *
+     * @param instruction The instructions to add.
+     */
+    fun MutableMethod.addInstruction(instruction: BuilderInstruction) =
+        implementation!!.addInstruction(instruction)
+
+    /**
+     * Add an instruction to a method at the given index.
+     *
+     * @param index The index to add the instruction at.
+     * @param smaliInstructions The instruction to add.
+     */
+    fun MutableMethod.addInstruction(index: Int, smaliInstructions: String) =
+        implementation!!.addInstruction(index, smaliInstructions.toInstruction(this))
+
+    /**
+     * Add an instruction to a method.
+     *
+     * @param smaliInstructions The instruction to add.
+     */
+    fun MutableMethod.addInstruction(smaliInstructions: String) =
+        implementation!!.addInstruction(smaliInstructions.toInstruction(this))
+
+
+    /**
+     * Add instructions to a method at the given index.
+     *
+     * @param index The index to add the instructions at.
+     * @param instructions The instructions to add.
+     */
+    fun MutableMethod.addInstructions(index: Int, instructions: List<BuilderInstruction>) =
+        implementation!!.addInstructions(index, instructions)
+
+    /**
+     * Add instructions to a method.
+     *
+     * @param instructions The instructions to add.
+     */
+    fun MutableMethod.addInstructions(instructions: List<BuilderInstruction>) =
+        implementation!!.addInstructions(instructions)
+
+    /**
+     * Add instructions to a method.
+     *
+     * @param smaliInstructions The instructions to add.
+     */
+    fun MutableMethod.addInstructions(index: Int, smaliInstructions: String) =
+        implementation!!.addInstructions(index, smaliInstructions.toInstructions(this))
+
+    /**
+     * Add instructions to a method.
+     *
+     * @param smaliInstructions The instructions to add.
+     */
+    fun MutableMethod.addInstructions(smaliInstructions: String) =
+        implementation!!.addInstructions(smaliInstructions.toInstructions(this))
+
+    /**
+     * Add instructions to a method at the given index.
+     *
+     * @param index The index to add the instructions at.
+     * @param smaliInstructions The instructions to add.
+     * @param externalLabels A list of [ExternalLabel] for instructions outside of [smaliInstructions].
+     */
+// Special function for adding instructions with external labels.
+    fun MutableMethod.addInstructionsWithLabels(
+        index: Int,
+        smaliInstructions: String,
+        vararg externalLabels: ExternalLabel
+    ) {
+        // Create reference dummy instructions for the instructions.
+        val nopSmali = StringBuilder(smaliInstructions).also { builder ->
+            externalLabels.forEach { (name, _) ->
+                builder.append("\n:$name\nnop")
+            }
+        }.toString()
+
+        // Compile the instructions with the dummy labels
+        val compiledInstructions = nopSmali.toInstructions(this)
+
+        // Add the compiled list of instructions to the method.
+        addInstructions(
+            index,
+            compiledInstructions.subList(0, compiledInstructions.size - externalLabels.size)
+        )
+
+        implementation!!.apply {
+            this@apply.instructions.subList(index, index + compiledInstructions.size - externalLabels.size)
+                .forEachIndexed { compiledInstructionIndex, compiledInstruction ->
+                    // If the compiled instruction is not an offset instruction, skip it.
+                    if (compiledInstruction !is BuilderOffsetInstruction) return@forEachIndexed
+
+                    /**
+                     * Creates a new label for the instruction
+                     * and replaces it with the label of the [compiledInstruction] at [compiledInstructionIndex].
+                     */
+                    fun Instruction.makeNewLabel() {
+                        fun replaceOffset(
+                            i: BuilderOffsetInstruction, label: Label
+                        ): BuilderOffsetInstruction {
+                            return when (i) {
+                                is BuilderInstruction10t -> BuilderInstruction10t(i.opcode, label)
+                                is BuilderInstruction20t -> BuilderInstruction20t(i.opcode, label)
+                                is BuilderInstruction21t -> BuilderInstruction21t(i.opcode, i.registerA, label)
+                                is BuilderInstruction22t -> BuilderInstruction22t(
+                                    i.opcode,
+                                    i.registerA,
+                                    i.registerB,
+                                    label
+                                )
+                                is BuilderInstruction30t -> BuilderInstruction30t(i.opcode, label)
+                                is BuilderInstruction31t -> BuilderInstruction31t(i.opcode, i.registerA, label)
+                                else -> throw IllegalStateException(
+                                    "A non-offset instruction was given, this should never happen!"
+                                )
+                            }
+                        }
+
+                        // Create the final label.
+                        val label = newLabelForIndex(this@apply.instructions.indexOf(this))
+
+                        // Create the final instruction with the new label.
+                        val newInstruction = replaceOffset(
+                            compiledInstruction, label
+                        )
+
+                        // Replace the instruction pointing to the dummy label
+                        // with the new instruction pointing to the real instruction.
+                        replaceInstruction(index + compiledInstructionIndex, newInstruction)
+                    }
+
+                    // If the compiled instruction targets its own instruction,
+                    // which means it points to some of its own, simply an offset has to be applied.
+                    val labelIndex = compiledInstruction.target.location.index
+                    if (labelIndex < compiledInstructions.size - externalLabels.size) {
+                        // Get the targets index (insertion index + the index of the dummy instruction).
+                        this.instructions[index + labelIndex].makeNewLabel()
+                        return@forEachIndexed
+                    }
+
+                    // Since the compiled instruction points to a dummy instruction,
+                    // we can find the real instruction which it was created for by calculation.
+
+                    // Get the index of the instruction in the externalLabels list
+                    // which the dummy instruction was created for.
+                    // This works because we created the dummy instructions in the same order as the externalLabels list.
+                    val (_, instruction) = externalLabels[(compiledInstructions.size - 1) - labelIndex]
+                    instruction.makeNewLabel()
+                }
+        }
+    }
+
+    /**
+     * Remove an instruction at the given index.
+     *
+     * @param index The index to remove the instruction at.
+     */
+    fun MutableMethod.removeInstruction(index: Int) =
+        implementation!!.removeInstruction(index)
+
+    /**
+     * Remove instructions at the given index.
+     *
+     * @param index The index to remove the instructions at.
+     * @param count The amount of instructions to remove.
+     */
+    fun MutableMethod.removeInstructions(index: Int, count: Int) =
+        implementation!!.removeInstructions(index, count)
+
+    /**
+     * Remove instructions at the given index.
+     *
+     * @param count The amount of instructions to remove.
+     */
+    fun MutableMethod.removeInstructions(count: Int) =
+        implementation!!.removeInstructions(count)
+
+    /**
+     * Replace an instruction at the given index.
+     *
+     * @param index The index to replace the instruction at.
+     * @param instruction The instruction to replace the instruction with.
+     */
+    fun MutableMethod.replaceInstruction(index: Int, instruction: BuilderInstruction) =
+        implementation!!.replaceInstruction(index, instruction)
+
+    /**
+     * Replace an instruction at the given index.
+     *
+     * @param index The index to replace the instruction at.
+     * @param smaliInstruction The smali instruction to replace the instruction with.
+     */
+    fun MutableMethod.replaceInstruction(index: Int, smaliInstruction: String) =
+        implementation!!.replaceInstruction(index, smaliInstruction.toInstruction(this))
+
+    /**
+     * Replace instructions at the given index.
+     *
+     * @param index The index to replace the instructions at.
+     * @param instructions The instructions to replace the instructions with.
+     */
+    fun MutableMethod.replaceInstructions(index: Int, instructions: List<BuilderInstruction>) =
+        implementation!!.replaceInstructions(index, instructions)
+
+    /**
+     * Replace instructions at the given index.
+     *
+     * @param index The index to replace the instructions at.
+     * @param smaliInstructions The smali instructions to replace the instructions with.
+     */
+    fun MutableMethod.replaceInstructions(index: Int, smaliInstructions: String) =
+        implementation!!.replaceInstructions(index, smaliInstructions.toInstructions(this))
+
+    /**
+     * Get an instruction at the given index.
+     *
+     * @param index The index to get the instruction at.
+     * @return The instruction.
+     */
+    fun MutableMethodImplementation.getInstruction(index: Int): BuilderInstruction = instructions[index]
+
+    /**
+     * Get an instruction at the given index.
+     *
+     * @param index The index to get the instruction at.
+     * @param T The type of instruction to return.
+     * @return The instruction.
+     */
+    @Suppress("UNCHECKED_CAST")
+    fun <T> MutableMethodImplementation.getInstruction(index: Int): T = getInstruction(index) as T
+
+    /**
+     * Get an instruction at the given index.
+     * @param index The index to get the instruction at.
+     * @return The instruction.
+     */
+    fun MutableMethod.getInstruction(index: Int): BuilderInstruction = implementation!!.getInstruction(index)
+
+    /**
+     * Get an instruction at the given index.
+     * @param index The index to get the instruction at.
+     * @param T The type of instruction to return.
+     * @return The instruction.
+     */
+    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/MethodFingerprintExtensions.kt

@@ -0,0 +1,20 @@
+package app.revanced.patcher.extensions
+
+import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
+import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+
+object MethodFingerprintExtensions {
+
+    /**
+     * The name of a [MethodFingerprint].
+     */
+    val MethodFingerprint.name: String
+        get() = this.javaClass.simpleName
+
+    /**
+     * The [FuzzyPatternScanMethod] annotation of a [MethodFingerprint].
+     */
+    val MethodFingerprint.fuzzyPatternScanMethod
+        get() = javaClass.findAnnotationRecursively(FuzzyPatternScanMethod::class)
+}

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

@@ -0,0 +1,72 @@
+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.PatchOptions
+import app.revanced.patcher.patch.annotations.DependsOn
+import app.revanced.patcher.patch.annotations.RequiresIntegrations
+import kotlin.reflect.KVisibility
+import kotlin.reflect.full.companionObject
+import kotlin.reflect.full.companionObjectInstance
+
+object PatchExtensions {
+    /**
+     * The name of a [Patch].
+     */
+    val Class<out Patch<Context>>.patchName: String
+        get() = findAnnotationRecursively(Name::class)?.name ?: this.simpleName
+
+    /**
+     * The version of a [Patch].
+     */
+    @Deprecated("This property is deprecated and will be removed in a future release.")
+    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
+        get() = findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class)!!.include
+
+    /**
+     * The description of a [Patch].
+     */
+    val Class<out Patch<Context>>.description
+        get() = findAnnotationRecursively(Description::class)?.description
+
+    /**
+     * The dependencies of a [Patch].
+     */
+    val Class<out Patch<Context>>.dependencies
+        get() = findAnnotationRecursively(DependsOn::class)?.dependencies
+
+    /**
+     * The packages a [Patch] is compatible with.
+     */
+    val Class<out Patch<Context>>.compatiblePackages
+        get() = findAnnotationRecursively(Compatibility::class)?.compatiblePackages
+
+    /**
+     * Weather or not a [Patch] requires integrations.
+     */
+    internal val Class<out Patch<Context>>.requiresIntegrations
+        get() = findAnnotationRecursively(RequiresIntegrations::class) != null
+
+    /**
+     * The options of a [Patch].
+     */
+    val Class<out Patch<Context>>.options: PatchOptions?
+        get() = kotlin.companionObject?.let { cl ->
+            if (cl.visibility != KVisibility.PUBLIC) return null
+            kotlin.companionObjectInstance?.let {
+                (it as? OptionsContainer)?.options
+            }
+        }
+}

src/main/kotlin/app/revanced/patcher/fingerprint/method/annotation/MethodFingerprintMetadata.kt

@@ -2,31 +2,11 @@ package app.revanced.patcher.fingerprint.method.annotation
 
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
 
-/**
- * Annotations for a method which matches to a [MethodFingerprint].
- * @param definingClass The defining class name of the method.
- * @param name A suggestive name for the method which the [MethodFingerprint] was created for.
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-annotation class MatchingMethod(
-    val definingClass: String = "L<unspecified-class>;",
-    val name: String = "<unspecified-method>"
-)
-
 /**
  * Annotations to scan a pattern [MethodFingerprint] with fuzzy algorithm.
  * @param threshold if [threshold] or more of the opcodes do not match, skip.
  */
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
 annotation class FuzzyPatternScanMethod(
     val threshold: Int = 1
-)
-
-/**
- * Annotations to scan a pattern [MethodFingerprint] directly.
- */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-annotation class DirectPatternScanMethod
+)

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

@@ -1,54 +1,445 @@
 package app.revanced.patcher.fingerprint.method.impl
 
-import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.data.impl.MethodNotFoundException
-import app.revanced.patcher.extensions.MethodFingerprintExtensions.name
-import app.revanced.patcher.extensions.softCompareTo
+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.utils.MethodFingerprintUtils
+import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.patch.PatchResultError
 import app.revanced.patcher.util.proxy.ClassProxy
+import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Opcode
 import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.Method
+import org.jf.dexlib2.iface.instruction.Instruction
+import org.jf.dexlib2.iface.instruction.ReferenceInstruction
+import org.jf.dexlib2.iface.reference.StringReference
+import org.jf.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.
- * @param returnType The return type of the method.
- * @param access The access flags of the method.
- * @param parameters The parameters of the method.
- * @param opcodes The list of opcodes of the method.
- * @param strings A list of strings which a method contains.
+ * A fingerprint to resolve methods.
+ *
+ * @param returnType The method's return type compared using [String.startsWith].
+ * @param accessFlags The method's exact access flags using values of [AccessFlags].
+ * @param parameters The parameters of the method. Partial matches allowed and follow the same rules as [returnType].
+ * @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?,
-    internal val access: Int?,
-    internal val parameters: Iterable<String>?,
-    internal val opcodes: Iterable<Opcode?>?,
+    internal val returnType: String? = null,
+    internal val accessFlags: Int? = null,
+    internal val parameters: Iterable<String>? = null,
+    internal val opcodes: Iterable<Opcode?>? = null,
     internal val strings: Iterable<String>? = null,
-    internal val customFingerprint: ((methodDef: Method) -> Boolean)? = null
+    internal val customFingerprint: ((methodDef: Method, classDef: ClassDef) -> Boolean)? = null
 ) : Fingerprint {
     /**
-     * The result of the [MethodFingerprint] the [Method].
-     * @throws MethodNotFoundException If the resolution of the [Method] has not happened.
+     * The result of the [MethodFingerprint].
      */
     var result: MethodFingerprintResult? = null
-        get() = field ?: throw Exception("${this.name} has not been resolved yet.")
+
+    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()) throw PatchResultError("Map already initialized")
+
+            context.classes.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 PatchResultError("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].
+         *
+         * @param classes The classes on which to resolve the [MethodFingerprint] in.
+         * @param context The [BytecodeContext] to host proxies.
+         * @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...
+                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 MethodFingerprint.
+        }
+
+        /**
+         * Resolve a [MethodFingerprint] against a [ClassDef].
+         *
+         * @param forClass The class on which to resolve the [MethodFingerprint] in.
+         * @param context The [BytecodeContext] to host proxies.
+         * @return True if the resolution was successful, false otherwise.
+         */
+        fun MethodFingerprint.resolve(context: BytecodeContext, forClass: ClassDef): Boolean {
+            for (method in forClass.methods)
+                if (this.resolve(context, method, forClass))
+                    return true
+            return false
+        }
+
+        /**
+         * Resolve a [MethodFingerprint] against a [Method].
+         *
+         * @param method The class on which to resolve the [MethodFingerprint] in.
+         * @param forClass The class on which to resolve the [MethodFingerprint].
+         * @param context The [BytecodeContext] to host proxies.
+         * @return True if the resolution was successful or if the fingerprint is already resolved, false otherwise.
+         */
+        fun MethodFingerprint.resolve(context: BytecodeContext, method: Method, forClass: ClassDef): Boolean {
+            val methodFingerprint = this
+
+            if (methodFingerprint.result != null) return true
+
+            if (methodFingerprint.returnType != null && !method.returnType.startsWith(methodFingerprint.returnType))
+                return false
+
+            if (methodFingerprint.accessFlags != null && methodFingerprint.accessFlags != method.accessFlags)
+                return false
+
+
+            fun parametersEqual(
+                parameters1: Iterable<CharSequence>, parameters2: Iterable<CharSequence>
+            ): Boolean {
+                if (parameters1.count() != parameters2.count()) return false
+                val iterator1 = parameters1.iterator()
+                parameters2.forEach {
+                    if (!it.startsWith(iterator1.next())) return false
+                }
+                return true
+            }
+
+            if (methodFingerprint.parameters != null && !parametersEqual(
+                    methodFingerprint.parameters, // TODO: parseParameters()
+                    method.parameterTypes
+                )
+            ) return false
+
+            @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+            if (methodFingerprint.customFingerprint != null && !methodFingerprint.customFingerprint!!(method, forClass))
+                return false
+
+            val stringsScanResult: StringsScanResult? =
+                if (methodFingerprint.strings != null) {
+                    StringsScanResult(
+                        buildList {
+                            val implementation = method.implementation ?: return false
+
+                            val stringsList = methodFingerprint.strings.toMutableList()
+
+                            implementation.instructions.forEachIndexed { instructionIndex, instruction ->
+                                if (
+                                    instruction.opcode != Opcode.CONST_STRING &&
+                                    instruction.opcode != Opcode.CONST_STRING_JUMBO
+                                ) return@forEachIndexed
+
+                                val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+                                val index = stringsList.indexOfFirst(string::contains)
+                                if (index == -1) return@forEachIndexed
+
+                                add(
+                                    StringMatch(
+                                        string,
+                                        instructionIndex
+                                    )
+                                )
+                                stringsList.removeAt(index)
+                            }
+
+                            if (stringsList.isNotEmpty()) return false
+                        }
+                    )
+                } else null
+
+            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
+
+            methodFingerprint.result = MethodFingerprintResult(
+                method,
+                forClass,
+                MethodFingerprintResult.MethodFingerprintScanResult(
+                    patternScanResult,
+                    stringsScanResult
+                ),
+                context
+            )
+
+            return true
+        }
+
+        private fun MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.createWarnings(
+            pattern: Iterable<Opcode?>, instructions: Iterable<Instruction>
+        ) = buildList {
+            for ((patternIndex, instructionIndex) in (this@createWarnings.startIndex until this@createWarnings.endIndex).withIndex()) {
+                val originalOpcode = instructions.elementAt(instructionIndex).opcode
+                val patternOpcode = pattern.elementAt(patternIndex)
+
+                if (patternOpcode == null || patternOpcode.ordinal == originalOpcode.ordinal) continue
+
+                this.add(
+                    MethodFingerprintResult.MethodFingerprintScanResult.PatternScanResult.Warning(
+                        originalOpcode,
+                        patternOpcode,
+                        instructionIndex,
+                        patternIndex
+                    )
+                )
+            }
+        }
+    }
 }
 
 /**
- * Represents the result of a [MethodFingerprintUtils].
+ * Represents the result of a [MethodFingerprintResult].
+ *
  * @param method The matching method.
  * @param classDef The [ClassDef] that contains the matching [method].
- * @param patternScanResult Opcodes pattern scan result.
- * @param data The [BytecodeData] this [MethodFingerprintResult] is attached to, to create proxies.
+ * @param scanResult The result of scanning for the [MethodFingerprint].
+ * @param context The [BytecodeContext] this [MethodFingerprintResult] is attached to, to create proxies.
  */
 data class MethodFingerprintResult(
     val method: Method,
     val classDef: ClassDef,
-    val patternScanResult: PatternScanResult?,
-    internal val data: BytecodeData
+    val scanResult: MethodFingerprintScanResult,
+    internal val context: BytecodeContext
 ) {
     /**
      * Returns a mutable clone of [classDef]
@@ -56,7 +447,8 @@ data class MethodFingerprintResult(
      * Please note, this method allocates a [ClassProxy].
      * Use [classDef] where possible.
      */
-    val mutableClass by lazy { data.proxy(classDef).resolve() }
+    @Suppress("MemberVisibilityCanBePrivate")
+    val mutableClass by lazy { context.proxy(classDef).mutableClass }
 
     /**
      * Returns a mutable clone of [method]
@@ -66,33 +458,56 @@ data class MethodFingerprintResult(
      */
     val mutableMethod by lazy {
         mutableClass.methods.first {
-            it.softCompareTo(this.method)
+            MethodUtil.methodSignaturesMatch(it, this.method)
         }
     }
-}
 
-/**
- * The result of a pattern scan.
- * @param startIndex The start index of the instructions where to which this pattern matches.
- * @param endIndex The end index of the instructions where to which this pattern matches.
- * @param warnings A list of warnings considering this [PatternScanResult].
- */
-data class PatternScanResult(
-    val startIndex: Int,
-    val endIndex: Int,
-    var warnings: List<Warning>? = null
-) {
     /**
-     * Represents warnings of the pattern scan.
-     * @param correctOpcode The opcode the instruction list has.
-     * @param wrongOpcode The opcode the pattern list of the signature currently has.
-     * @param instructionIndex The index of the opcode relative to the instruction list.
-     * @param patternIndex The index of the opcode relative to the pattern list from the signature.
+     * The result of scanning on the [MethodFingerprint].
+     * @param patternScanResult The result of the pattern scan.
+     * @param stringsScanResult The result of the string scan.
      */
-    data class Warning(
-        val correctOpcode: Opcode,
-        val wrongOpcode: Opcode,
-        val instructionIndex: Int,
-        val patternIndex: Int,
-    )
+    data class MethodFingerprintScanResult(
+        val patternScanResult: PatternScanResult?,
+        val stringsScanResult: StringsScanResult?
+    ) {
+        /**
+         * The result of scanning strings on the [MethodFingerprint].
+         * @param matches The list of strings that were matched.
+         */
+        data class StringsScanResult(val matches: List<StringMatch>) {
+            /**
+             * Represents a match for a string at an index.
+             * @param string The string that was matched.
+             * @param index The index of the string.
+             */
+            data class StringMatch(val string: String, val index: Int)
+        }
+
+        /**
+         * The result of a pattern scan.
+         * @param startIndex The start index of the instructions where to which this pattern matches.
+         * @param endIndex The end index of the instructions where to which this pattern matches.
+         * @param warnings A list of warnings considering this [PatternScanResult].
+         */
+        data class PatternScanResult(
+            val startIndex: Int,
+            val endIndex: Int,
+            var warnings: List<Warning>? = null
+        ) {
+            /**
+             * Represents warnings of the pattern scan.
+             * @param correctOpcode The opcode the instruction list has.
+             * @param wrongOpcode The opcode the pattern list of the signature currently has.
+             * @param instructionIndex The index of the opcode relative to the instruction list.
+             * @param patternIndex The index of the opcode relative to the pattern list from the signature.
+             */
+            data class Warning(
+                val correctOpcode: Opcode,
+                val wrongOpcode: Opcode,
+                val instructionIndex: Int,
+                val patternIndex: Int,
+            )
+        }
+    }
 }

src/main/kotlin/app/revanced/patcher/fingerprint/method/utils/MethodFingerprintUtils.kt

@@ -1,158 +0,0 @@
-package app.revanced.patcher.fingerprint.method.utils
-
-import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyPatternScanMethod
-import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyScanThreshold
-import app.revanced.patcher.extensions.parametersEqual
-import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprintResult
-import app.revanced.patcher.fingerprint.method.impl.PatternScanResult
-import org.jf.dexlib2.Opcode
-import org.jf.dexlib2.iface.ClassDef
-import org.jf.dexlib2.iface.Method
-import org.jf.dexlib2.iface.instruction.Instruction
-import org.jf.dexlib2.iface.instruction.ReferenceInstruction
-import org.jf.dexlib2.iface.reference.StringReference
-
-/**
- * Utility class for [MethodFingerprint]
- */
-object MethodFingerprintUtils {
-    /**
-     * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
-     * @param context The classes on which to resolve the [MethodFingerprint].
-     * @param forData The [BytecodeData] to host proxies.
-     * @return True if the resolution was successful, false otherwise.
-     */
-    fun Iterable<MethodFingerprint>.resolve(forData: BytecodeData, context: Iterable<ClassDef>) {
-        for (fingerprint in this) // For each fingerprint
-            classes@ for (classDef in context) // search through all classes for the fingerprint
-                if (fingerprint.resolve(forData, classDef))
-                    break@classes // if the resolution succeeded, continue with the next fingerprint
-    }
-
-    /**
-     * Resolve a [MethodFingerprint] against a [ClassDef].
-     * @param context The class on which to resolve the [MethodFingerprint].
-     * @param forData The [BytecodeData] to host proxies.
-     * @return True if the resolution was successful, false otherwise.
-     */
-    fun MethodFingerprint.resolve(forData: BytecodeData, context: ClassDef): Boolean {
-        for (method in context.methods)
-            if (this.resolve(forData, method, context))
-                return true
-        return false
-    }
-
-    /**
-     * Resolve a [MethodFingerprint] against a [Method].
-     * @param context The context on which to resolve the [MethodFingerprint].
-     * @param classDef The class of the matching [Method].
-     * @param forData The [BytecodeData] to host proxies.
-     * @return True if the resolution was successful, false otherwise.
-     */
-    fun MethodFingerprint.resolve(forData: BytecodeData, context: Method, classDef: ClassDef): Boolean {
-        val methodFingerprint = this
-
-        if (methodFingerprint.returnType != null && !context.returnType.startsWith(methodFingerprint.returnType))
-            return false
-
-        if (methodFingerprint.access != null && methodFingerprint.access != context.accessFlags)
-            return false
-
-
-        if (methodFingerprint.parameters != null && !parametersEqual(
-                methodFingerprint.parameters, // TODO: parseParameters()
-                context.parameterTypes
-            )
-        ) return false
-
-        if (methodFingerprint.customFingerprint != null && !methodFingerprint.customFingerprint!!(context))
-            return false
-
-        if (methodFingerprint.strings != null) {
-            val implementation = context.implementation ?: return false
-
-            val stringsList = methodFingerprint.strings.toMutableList()
-
-            implementation.instructions.forEach { instruction ->
-                if (instruction.opcode.ordinal != Opcode.CONST_STRING.ordinal) return@forEach
-
-                val string = ((instruction as ReferenceInstruction).reference as StringReference).string
-                val index = stringsList.indexOfFirst { it == string }
-                if (index != -1) stringsList.removeAt(index)
-            }
-
-            if (stringsList.isNotEmpty()) return false
-        }
-
-        val patternScanResult = if (methodFingerprint.opcodes != null) {
-            context.implementation?.instructions ?: return false
-
-            context.patternScan(methodFingerprint) ?: return false
-        } else null
-
-        methodFingerprint.result = MethodFingerprintResult(context, classDef, patternScanResult, forData)
-
-        return true
-    }
-
-    private fun Method.patternScan(
-        fingerprint: MethodFingerprint
-    ): PatternScanResult? {
-        val instructions = this.implementation!!.instructions
-        val fingerprintFuzzyPatternScanThreshold = fingerprint.fuzzyScanThreshold
-
-        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 = PatternScanResult(index, index + patternIndex)
-                if (fingerprint.fuzzyPatternScanMethod !is FuzzyPatternScanMethod) return result
-                result.warnings = result.createWarnings(pattern, instructions)
-
-                return result
-            }
-        }
-
-        return null
-    }
-}
-
-private fun PatternScanResult.createWarnings(
-    pattern: Iterable<Opcode?>, instructions: Iterable<Instruction>
-) = buildList {
-    for ((patternIndex, instructionIndex) in (this@createWarnings.startIndex until this@createWarnings.endIndex).withIndex()) {
-        val originalOpcode = instructions.elementAt(instructionIndex).opcode
-        val patternOpcode = pattern.elementAt(patternIndex)
-
-        if (patternOpcode == null || patternOpcode.ordinal == originalOpcode.ordinal) continue
-
-        this.add(PatternScanResult.Warning(originalOpcode, patternOpcode, instructionIndex, patternIndex))
-    }
-}
-
-private operator fun ClassDef.component1() = this
-private operator fun ClassDef.component2() = this.methods

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

@@ -0,0 +1,18 @@
+package app.revanced.patcher.patch
+
+/**
+ * A container for patch options.
+ */
+abstract class OptionsContainer {
+    /**
+     * A list of [PatchOption]s.
+     * @see PatchOptions
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    val options = PatchOptions()
+
+    protected fun <T> option(opt: PatchOption<T>): PatchOption<T> {
+        options.register(opt)
+        return opt
+    }
+}

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

@@ -1,18 +1,37 @@
 package app.revanced.patcher.patch
 
-import app.revanced.patcher.data.Data
-import app.revanced.patcher.patch.impl.BytecodePatch
-import app.revanced.patcher.patch.impl.ResourcePatch
-
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.data.Context
+import app.revanced.patcher.data.ResourceContext
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import java.io.Closeable
 
 /**
  * A ReVanced patch.
- * Can either be a [ResourcePatch] or a [BytecodePatch].
+ *
+ * If it implements [Closeable], it will be closed after all patches have been executed.
+ * Closing will be done in reverse execution order.
  */
-abstract class Patch<out T : Data> {
-
+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.
      */
-    abstract fun execute(data: @UnsafeVariance T): PatchResult
-}
+    fun execute(context: @UnsafeVariance T): PatchResult
+}
+
+/**
+ * Resource patch for the Patcher.
+ */
+interface ResourcePatch : Patch<ResourceContext>
+
+/**
+ * Bytecode patch for the Patcher.
+ *
+ * @param fingerprints A list of [MethodFingerprint] this patch relies on.
+ */
+abstract class BytecodePatch(
+    internal val fingerprints: Iterable<MethodFingerprint>? = null
+) : Patch<BytecodeContext>

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

@@ -0,0 +1,232 @@
+@file:Suppress("CanBeParameter", "MemberVisibilityCanBePrivate", "UNCHECKED_CAST")
+
+package app.revanced.patcher.patch
+
+import java.nio.file.Path
+import kotlin.io.path.pathString
+import kotlin.reflect.KProperty
+
+class NoSuchOptionException(val option: String) : Exception("No such option: $option")
+class IllegalValueException(val value: Any?) : Exception("Illegal value: $value")
+class InvalidTypeException(val got: String, val expected: String) :
+    Exception("Invalid option value type: $got, expected $expected")
+
+object RequirementNotMetException : Exception("null was passed into an option that requires a value")
+
+/**
+ * A registry for an array of [PatchOption]s.
+ * @param options An array of [PatchOption]s.
+ */
+class PatchOptions(vararg options: PatchOption<*>) : Iterable<PatchOption<*>> {
+    private val register = mutableMapOf<String, PatchOption<*>>()
+
+    init {
+        options.forEach { register(it) }
+    }
+
+    internal fun register(option: PatchOption<*>) {
+        if (register.containsKey(option.key)) {
+            throw IllegalStateException("Multiple options found with the same key")
+        }
+        register[option.key] = option
+    }
+
+    /**
+     * Get a [PatchOption] by its key.
+     * @param key The key of the [PatchOption].
+     */
+    @JvmName("getUntyped")
+    operator fun get(key: String) = register[key] ?: throw NoSuchOptionException(key)
+
+    /**
+     * Get a [PatchOption] by its key.
+     * @param key The key of the [PatchOption].
+     */
+    inline operator fun <reified T> get(key: String): PatchOption<T> {
+        val opt = get(key)
+        if (opt.value !is T) throw InvalidTypeException(
+            opt.value?.let { it::class.java.canonicalName } ?: "null",
+            T::class.java.canonicalName
+        )
+        return opt as PatchOption<T>
+    }
+
+    /**
+     * Set the value of a [PatchOption].
+     * @param key The key of the [PatchOption].
+     * @param value The value you want it to be.
+     * Please note that using the wrong value type results in a runtime error.
+     */
+    inline operator fun <reified T> set(key: String, value: T) {
+        val opt = get<T>(key)
+        if (opt.value !is T) throw InvalidTypeException(
+            T::class.java.canonicalName,
+            opt.value?.let { it::class.java.canonicalName } ?: "null"
+        )
+        opt.value = value
+    }
+
+    /**
+     * Sets the value of a [PatchOption] to `null`.
+     * @param key The key of the [PatchOption].
+     */
+    fun nullify(key: String) {
+        get(key).value = null
+    }
+
+    override fun iterator() = register.values.iterator()
+}
+
+/**
+ * A [Patch] option.
+ * @param key Unique identifier of the option. Example: _`settings.microg.enabled`_
+ * @param default The default value of the option.
+ * @param title A human-readable title of the option. Example: _MicroG Settings_
+ * @param description A human-readable description of the option. Example: _Settings integration for MicroG._
+ * @param required Whether the option is required.
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+sealed class PatchOption<T>(
+    val key: String,
+    default: T?,
+    val title: String,
+    val description: String,
+    val required: Boolean,
+    val validator: (T?) -> Boolean
+) {
+    var value: T? = default
+        get() {
+            if (field == null && required) {
+                throw RequirementNotMetException
+            }
+            return field
+        }
+        set(value) {
+            if (value == null && required) {
+                throw RequirementNotMetException
+            }
+            if (!validator(value)) {
+                throw IllegalValueException(value)
+            }
+            field = value
+        }
+
+    /**
+     * Gets the value of the option.
+     * Please note that using the wrong value type results in a runtime error.
+     */
+    @JvmName("getValueTyped")
+    inline operator fun <reified V> getValue(thisRef: Nothing?, property: KProperty<*>): V? {
+        if (value !is V?) throw InvalidTypeException(
+            V::class.java.canonicalName,
+            value?.let { it::class.java.canonicalName } ?: "null"
+        )
+        return value as? V?
+    }
+
+    operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
+
+    /**
+     * Gets the value of the option.
+     * Please note that using the wrong value type results in a runtime error.
+     */
+    @JvmName("setValueTyped")
+    inline operator fun <reified V> setValue(thisRef: Nothing?, property: KProperty<*>, new: V) {
+        if (value !is V) throw InvalidTypeException(
+            V::class.java.canonicalName,
+            value?.let { it::class.java.canonicalName } ?: "null"
+        )
+        value = new as T
+    }
+
+    operator fun setValue(thisRef: Any?, property: KProperty<*>, new: T?) {
+        value = new
+    }
+
+    /**
+     * A [PatchOption] representing a [String].
+     * @see PatchOption
+     */
+    class StringOption(
+        key: String,
+        default: String?,
+        title: String,
+        description: String,
+        required: Boolean = false,
+        validator: (String?) -> Boolean = { true }
+    ) : PatchOption<String>(
+        key, default, title, description, required, validator
+    )
+
+    /**
+     * A [PatchOption] representing a [Boolean].
+     * @see PatchOption
+     */
+    class BooleanOption(
+        key: String,
+        default: Boolean?,
+        title: String,
+        description: String,
+        required: Boolean = false,
+        validator: (Boolean?) -> Boolean = { true }
+    ) : PatchOption<Boolean>(
+        key, default, title, description, required, validator
+    )
+
+    /**
+     * A [PatchOption] with a list of allowed options.
+     * @param options A list of allowed options for the [ListOption].
+     * @see PatchOption
+     */
+    sealed class ListOption<E>(
+        key: String,
+        default: E?,
+        val options: Iterable<E>,
+        title: String,
+        description: String,
+        required: Boolean = false,
+        validator: (E?) -> Boolean = { true }
+    ) : PatchOption<E>(
+        key, default, title, description, required, {
+            (it?.let { it in options } ?: true) && validator(it)
+        }
+    ) {
+        init {
+            if (default != null && default !in options) {
+                throw IllegalStateException("Default option must be an allowed option")
+            }
+        }
+    }
+
+    /**
+     * A [ListOption] of type [String].
+     * @see ListOption
+     */
+    class StringListOption(
+        key: String,
+        default: String?,
+        options: Iterable<String>,
+        title: String,
+        description: String,
+        required: Boolean = false,
+        validator: (String?) -> Boolean = { true }
+    ) : ListOption<String>(
+        key, default, options, title, description, required, validator
+    )
+
+    /**
+     * A [ListOption] of type [Int].
+     * @see ListOption
+     */
+    class IntListOption(
+        key: String,
+        default: Int?,
+        options: Iterable<Int>,
+        title: String,
+        description: String,
+        required: Boolean = false,
+        validator: (Int?) -> Boolean = { true }
+    ) : ListOption<Int>(
+        key, default, options, title, description, required, validator
+    )
+}

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

@@ -1,24 +1,27 @@
 package app.revanced.patcher.patch.annotations
 
-import app.revanced.patcher.data.Data
+import app.revanced.patcher.data.Context
 import app.revanced.patcher.patch.Patch
 import kotlin.reflect.KClass
 
 /**
- * Annotation to mark a Class as a patch.
+ * Annotation to mark a class as a patch.
  * @param include If false, the patch should be treated as optional by default.
  */
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
 annotation class Patch(val include: Boolean = true)
 
 /**
- * Annotation for dependencies of [Patch]es .
+ * Annotation for dependencies of [Patch]es.
  */
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
-@MustBeDocumented
-annotation class Dependencies(
-    val dependencies: Array<KClass<out Patch<Data>>> = []
-)
+annotation class DependsOn(
+    val dependencies: Array<KClass<out Patch<Context>>> = []
+)
+
+
+/**
+ * Annotation to mark [Patch]es which depend on integrations.
+ */
+@Target(AnnotationTarget.CLASS)
+annotation class RequiresIntegrations // required because integrations are decoupled from patches

src/main/kotlin/app/revanced/patcher/patch/impl/BytecodePatch.kt

@@ -1,13 +0,0 @@
-package app.revanced.patcher.patch.impl
-
-import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.patch.Patch
-
-/**
- * Bytecode patch for the Patcher.
- * @param fingerprints A list of [MethodFingerprint] this patch relies on.
- */
-abstract class BytecodePatch(
-    internal val fingerprints: Iterable<MethodFingerprint>
-) : Patch<BytecodeData>()

src/main/kotlin/app/revanced/patcher/patch/impl/ResourcePatch.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.patch.impl
-
-import app.revanced.patcher.data.impl.ResourceData
-import app.revanced.patcher.patch.Patch
-
-/**
- * Resource patch for the Patcher.
- */
-abstract class ResourcePatch : Patch<ResourceData>()

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

@@ -0,0 +1,214 @@
+package app.revanced.patcher.util
+
+import app.revanced.patcher.PatcherContext
+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.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 org.jf.dexlib2.iface.ClassDef
+import org.jf.dexlib2.util.MethodUtil
+import kotlin.reflect.KFunction2
+
+/**
+ * Experimental class to merge a [ClassDef] with another.
+ * Note: This will not consider method implementations or if the class is missing a superclass or interfaces.
+ */
+internal object ClassMerger {
+    /**
+     * 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.
+     */
+    fun ClassDef.merge(otherClass: ClassDef, context: PatcherContext, logger: Logger? = null) = this
+        //.fixFieldAccess(otherClass, logger)
+        //.fixMethodAccess(otherClass, logger)
+        .addMissingFields(otherClass, logger)
+        .addMissingMethods(otherClass, logger)
+        .publicize(otherClass, context, logger)
+
+    /**
+     * 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 {
+        val missingMethods = fromClass.methods.let { fromMethods ->
+            methods.filterNot { method ->
+                fromMethods.any { fromMethod ->
+                    MethodUtil.methodSignaturesMatch(fromMethod, method)
+                }
+            }
+        }
+
+        if (missingMethods.isEmpty()) return this
+
+        logger?.trace("Found ${missingMethods.size} missing methods")
+
+        return asMutableClass().apply {
+            methods.addAll(missingMethods.map { it.toMutable() })
+        }
+    }
+
+    /**
+     * 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 {
+        val missingFields = fields.filterNotAny(fromClass.fields) { field, fromField ->
+            fromField.name == field.name
+        }
+
+        if (missingFields.isEmpty()) return this
+
+        logger?.trace("Found ${missingFields.size} missing fields")
+
+        return asMutableClass().apply {
+            fields.addAll(missingFields.map { it.toMutable() })
+        }
+    }
+
+    /**
+     * 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) =
+        if (reference.accessFlags.isPublic() && !accessFlags.isPublic())
+            this.asMutableClass().apply {
+                context.bytecodeContext.traverseClassHierarchy(this) {
+                    if (accessFlags.isPublic()) return@traverseClassHierarchy
+
+                    logger?.trace("Publicizing ${this.type}")
+
+                    accessFlags = accessFlags.toPublic()
+                }
+            }
+        else this
+
+    /**
+     * 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 {
+        val brokenFields = fields.filterAny(reference.fields) { field, referenceField ->
+            if (field.name != referenceField.name) return@filterAny false
+
+            referenceField.accessFlags.isPublic() && !field.accessFlags.isPublic()
+        }
+
+        if (brokenFields.isEmpty()) return this
+
+        logger?.trace("Found ${brokenFields.size} broken fields")
+
+        /**
+         * Make a field public.
+         */
+        fun MutableField.publicize() {
+            accessFlags = accessFlags.toPublic()
+        }
+
+        return asMutableClass().apply {
+            fields.filter { brokenFields.contains(it) }.forEach(MutableField::publicize)
+        }
+    }
+
+    /**
+     * 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 {
+        val brokenMethods = methods.filterAny(reference.methods) { method, referenceMethod ->
+            if (!MethodUtil.methodSignaturesMatch(method, referenceMethod)) return@filterAny false
+
+            referenceMethod.accessFlags.isPublic() && !method.accessFlags.isPublic()
+        }
+
+        if (brokenMethods.isEmpty()) return this
+
+        logger?.trace("Found ${brokenMethods.size} methods")
+
+        /**
+         * Make a method public.
+         */
+        fun MutableMethod.publicize() {
+            accessFlags = accessFlags.toPublic()
+        }
+
+        return asMutableClass().apply {
+            methods.filter { brokenMethods.contains(it) }.forEach(MutableMethod::publicize)
+        }
+    }
+
+    private object Utils {
+        fun ClassDef.asMutableClass() = if (this is MutableClass) this else this.toMutable()
+
+        /**
+         * Check if the [AccessFlags.PUBLIC] flag is set.
+         *
+         * @return True, if the flag is set.
+         */
+        fun Int.isPublic() = AccessFlags.PUBLIC.isSet(this)
+
+        /**
+         * Make [AccessFlags] public.
+         *
+         * @return The new [AccessFlags].
+         */
+        fun Int.toPublic() = this.or(AccessFlags.PUBLIC).and(AccessFlags.PRIVATE.value.inv())
+
+        /**
+         * 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].
+         */
+        fun <HayType, NeedleType> Iterable<HayType>.filterAny(
+            needles: Iterable<NeedleType>, predicate: (HayType, NeedleType) -> Boolean
+        ) = Iterable<HayType>::filter.any(this, needles, predicate)
+
+        /**
+         * 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].
+         */
+        fun <HayType, NeedleType> Iterable<HayType>.filterNotAny(
+            needles: Iterable<NeedleType>, predicate: (HayType, NeedleType) -> Boolean
+        ) = Iterable<HayType>::filterNot.any(this, needles, predicate)
+
+        fun <HayType, NeedleType> KFunction2<Iterable<HayType>, (HayType) -> Boolean, List<HayType>>.any(
+            haystack: Iterable<HayType>,
+            needles: Iterable<NeedleType>,
+            predicate: (HayType, NeedleType) -> Boolean
+        ) = this(haystack) { hay ->
+            needles.any { needle ->
+                predicate(hay, needle)
+            }
+        }
+    }
+}

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

@@ -3,40 +3,44 @@ 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> {
-    private val internalProxies = mutableListOf<ClassProxy>()
-    internal val proxies: List<ClassProxy> = internalProxies
-
-    fun add(classDef: ClassDef) = internalClasses.add(classDef)
-    fun add(classProxy: ClassProxy) = internalProxies.add(classProxy)
+/**
+ * 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>()
 
     /**
-     * Apply all resolved classes into [internalClasses] and clean the [proxies] list.
+     * Add a [ClassDef].
      */
-    internal fun applyProxies() {
-        // FIXME: check if this could cause issues when multiple patches use the same proxy
-        internalProxies.removeIf { proxy ->
-            // if the proxy is unused, keep it in the list
-            if (!proxy.proxyUsed) return@removeIf false
+    fun add(classDef: ClassDef) = classes.add(classDef)
 
-            // if it has been used, replace the internal class which it proxied
-            val index = internalClasses.indexOfFirst { it.type == proxy.immutableClass.type }
-            internalClasses[index] = proxy.mutatedClass
+    /**
+     * 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() = internalClasses.size
-    override fun contains(element: ClassDef) = internalClasses.contains(element)
-    override fun containsAll(elements: Collection<ClassDef>) = internalClasses.containsAll(elements)
-    override fun get(index: Int) = internalClasses[index]
-    override fun indexOf(element: ClassDef) = internalClasses.indexOf(element)
-    override fun isEmpty() = internalClasses.isEmpty()
-    override fun iterator() = internalClasses.iterator()
-    override fun lastIndexOf(element: ClassDef) = internalClasses.lastIndexOf(element)
-    override fun listIterator() = internalClasses.listIterator()
-    override fun listIterator(index: Int) = internalClasses.listIterator(index)
-    override fun subList(fromIndex: Int, toIndex: Int) = internalClasses.subList(fromIndex, toIndex)
+
+    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/TypeUtil.kt

@@ -0,0 +1,19 @@
+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/dex/DexFile.kt

@@ -5,6 +5,6 @@ import java.io.InputStream
 /**
  * Wrapper for dex files.
  * @param name The original name of the dex file.
- * @param dexFileInputStream The dex file as [InputStream].
+ * @param stream The dex file as [InputStream].
  */
-data class DexFile(val name: String, val dexFileInputStream: InputStream)
+data class DexFile(val name: String, val stream: InputStream)

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

@@ -1,27 +1,27 @@
 package app.revanced.patcher.util.method
 
-import app.revanced.patcher.data.impl.BytecodeData
-import app.revanced.patcher.data.impl.MethodNotFoundException
-import app.revanced.patcher.extensions.softCompareTo
+import app.revanced.patcher.data.BytecodeContext
 import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
-import org.jf.dexlib2.Format
 import org.jf.dexlib2.iface.Method
-import org.jf.dexlib2.iface.instruction.formats.Instruction35c
+import org.jf.dexlib2.iface.instruction.ReferenceInstruction
 import org.jf.dexlib2.iface.reference.MethodReference
-import org.jf.dexlib2.util.Preconditions
+import org.jf.dexlib2.util.MethodUtil
 
 /**
  * Find a method from another method via instruction offsets.
- * @param bytecodeData The bytecodeData to use when resolving the next method reference.
+ * @param bytecodeContext The context to use when resolving the next method reference.
  * @param currentMethod The method to start from.
  */
 class MethodWalker internal constructor(
-    private val bytecodeData: BytecodeData,
+    private val bytecodeContext: BytecodeContext,
     private var currentMethod: Method
 ) {
     /**
      * Get the method which was walked last.
+     *
      * It is possible to cast this method to a [MutableMethod], if the method has been walked mutably.
+     *
+     * @return The method which was walked last.
      */
     fun getMethod(): Method {
         return currentMethod
@@ -29,27 +29,28 @@ class MethodWalker internal constructor(
 
     /**
      * Walk to a method defined at the offset in the instruction list of the current method.
+     *
+     * The current method will be mutable.
+     *
      * @param offset The offset of the instruction. This instruction must be of format 35c.
      * @param walkMutable If this is true, the class of the method will be resolved mutably.
-     * The current method will be mutable.
+     * @return The same [MethodWalker] instance with the method at [offset].
      */
     fun nextMethod(offset: Int, walkMutable: Boolean = false): MethodWalker {
         currentMethod.implementation?.instructions?.let { instructions ->
             val instruction = instructions.elementAt(offset)
 
-            Preconditions.checkFormat(instruction.opcode, Format.Format35c)
+            val newMethod = (instruction as ReferenceInstruction).reference as MethodReference
+            val proxy = bytecodeContext.findClass(newMethod.definingClass)!!
 
-            val newMethod = (instruction as Instruction35c).reference as MethodReference
-            val proxy = bytecodeData.findClass(newMethod.definingClass)!!
-
-            val methods = if (walkMutable) proxy.resolve().methods else proxy.immutableClass.methods
-            currentMethod = methods.first { it ->
-                return@first it.softCompareTo(newMethod)
+            val methods = if (walkMutable) proxy.mutableClass.methods else proxy.immutableClass.methods
+            currentMethod = methods.first {
+                return@first MethodUtil.methodSignaturesMatch(it, newMethod)
             }
             return this
         }
         throw MethodNotFoundException("This method can not be walked at offset $offset inside the method ${currentMethod.name}")
     }
 
-
+    internal class MethodNotFoundException(exception: String) : Exception(exception)
 }

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

@@ -0,0 +1,76 @@
+@file:Suppress("unused")
+
+package app.revanced.patcher.util.patch
+
+import app.revanced.patcher.data.Context
+import app.revanced.patcher.extensions.AnnotationExtensions.findAnnotationRecursively
+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)
+
+            // Annotations can not Patch.
+            if (clazz.isAnnotation) return@forEach
+
+            clazz.findAnnotationRecursively(app.revanced.patcher.patch.annotations.Patch::class)
+                ?: 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.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/patch/base/PatchBundle.kt

@@ -1,18 +0,0 @@
-package app.revanced.patcher.util.patch.base
-
-import app.revanced.patcher.data.Data
-import app.revanced.patcher.patch.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

@@ -1,17 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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/proxy/ClassProxy.kt

@@ -8,34 +8,26 @@ import org.jf.dexlib2.iface.ClassDef
  *
  * A class proxy simply holds a reference to the original class
  * and allocates a mutable clone for the original class if needed.
- * @param immutableClass The class to proxy
+ * @param immutableClass The class to proxy.
  */
-class ClassProxy(
+class ClassProxy internal constructor(
     val immutableClass: ClassDef,
 ) {
-    internal var proxyUsed = false
-    internal lateinit var mutatedClass: MutableClass
-
-    init {
-        // in the instance, that a [MutableClass] is being proxied,
-        // do not create an additional clone and reuse the [MutableClass] instance
-        if (immutableClass is MutableClass) {
-            mutatedClass = immutableClass
-            proxyUsed = true
-        }
-    }
+    /**
+     * Weather the proxy was actually used.
+     */
+    internal var resolved = false
 
     /**
-     * Allocates and returns a mutable clone of the original class.
-     * A patch should always use the original immutable class reference
-     * to avoid unnecessary allocations for the mutable class.
-     * @return A mutable clone of the original class.
+     * The mutable clone of the original class.
+     *
+     * Note: This is only allocated if the proxy is actually used.
      */
-    fun resolve(): MutableClass {
-        if (!proxyUsed) {
-            proxyUsed = true
-            mutatedClass = MutableClass(immutableClass)
-        }
-        return mutatedClass
+    val mutableClass by lazy {
+        resolved = true
+        if (immutableClass is MutableClass) {
+            immutableClass
+        } else
+            MutableClass(immutableClass)
     }
 }

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

@@ -20,6 +20,22 @@ class MutableMethod(method: Method) : Method, BaseMethodReference() {
     private val _parameterTypes by lazy { method.parameterTypes.toMutableList() }
     private val _hiddenApiRestrictions by lazy { method.hiddenApiRestrictions }
 
+    fun setDefiningClass(definingClass: String) {
+        this.definingClass = definingClass
+    }
+
+    fun setName(name: String) {
+        this.name = name
+    }
+
+    fun setAccessFlags(accessFlags: Int) {
+        this.accessFlags = accessFlags
+    }
+
+    fun setReturnType(returnType: String) {
+        this.returnType = returnType
+    }
+
     override fun getDefiningClass(): String {
         return definingClass
     }

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

@@ -0,0 +1,10 @@
+package app.revanced.patcher.util.smali
+
+import org.jf.dexlib2.iface.instruction.Instruction
+
+/**
+ * A class that represents a label for an instruction.
+ * @param name The label name.
+ * @param instruction The instruction that this label is for.
+ */
+data class ExternalLabel(internal val name: String, internal val instruction: Instruction)

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

@@ -1,12 +1,12 @@
 package app.revanced.patcher.util.smali
 
+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 org.jf.dexlib2.Opcodes
 import org.jf.dexlib2.builder.BuilderInstruction
-import org.jf.dexlib2.iface.Method
 import org.jf.dexlib2.writer.builder.DexBuilder
 import org.jf.smali.LexerErrorInterface
 import org.jf.smali.smaliFlexLexer
@@ -27,18 +27,19 @@ class InlineSmaliCompiler {
     companion object {
         /**
          * Compiles a string of Smali code to a list of instructions.
-         * p0, p1 etc. will only work correctly if the parameters and registers are passed.
-         * Do not cross the boundaries of the control flow (if-nez insn, etc),
-         * as that will result in exceptions since the labels cannot be calculated.
-         * Do not create dummy labels to fix the issue, since the code addresses will
-         * be messed up and results in broken Dalvik bytecode.
-         * FIXME: Fix the above issue. When this is fixed, add the proper conversions in [InstructionConverter].
+         * Special registers (such as p0, p1) will only work correctly
+         * if the parameters and registers of the method are passed.
          */
         fun compile(
             instructions: String, parameters: String, registers: Int, forStaticMethod: Boolean
         ): List<BuilderInstruction> {
-            val input =
-                METHOD_TEMPLATE.format(if (forStaticMethod) "static" else "", 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)
@@ -54,25 +55,30 @@ class InlineSmaliCompiler {
             val dexGen = smaliTreeWalker(treeStream)
             dexGen.setDexBuilder(DexBuilder(Opcodes.getDefault()))
             val classDef = dexGen.smali_file()
-            return classDef.methods.first().implementation!!.instructions.map { it.toBuilderInstruction() }
+            return classDef.methods.first().implementation!!.instructions.map { it as BuilderInstruction }
         }
     }
 }
 
 /**
  * Compile lines of Smali code to a list of instructions.
- * @param templateMethod The method to compile the instructions against.
+ *
+ * Note: Adding compiled instructions to an existing method with
+ * offset instructions WITHOUT specifying a parent method will not work.
+ * @param method The method to compile the instructions against.
  * @returns A list of instructions.
  */
-fun String.toInstructions(templateMethod: Method? = null) = InlineSmaliCompiler.compile(this,
-    templateMethod?.parameters?.joinToString("") { it } ?: "",
-    templateMethod?.implementation?.registerCount ?: 1,
-    templateMethod?.let { AccessFlags.STATIC.isSet(it.accessFlags) } ?: true
-)
+fun String.toInstructions(method: MutableMethod? = null): List<BuilderInstruction> {
+    return InlineSmaliCompiler.compile(this,
+        method?.parameters?.joinToString("") { it } ?: "",
+        method?.implementation?.registerCount ?: 1,
+        method?.let { AccessFlags.STATIC.isSet(it.accessFlags) } ?: true
+    )
+}
 
 /**
  * Compile a line of Smali code to an instruction.
  * @param templateMethod The method to compile the instructions against.
  * @return The instruction.
  */
-fun String.toInstruction(templateMethod: Method? = null) = this.toInstructions(templateMethod).first()
+fun String.toInstruction(templateMethod: MutableMethod? = null) = this.toInstructions(templateMethod).first()

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

@@ -1,261 +0,0 @@
-package app.revanced.patcher.util.smali
-
-import org.jf.dexlib2.Format
-import org.jf.dexlib2.builder.instruction.*
-import org.jf.dexlib2.iface.instruction.Instruction
-import org.jf.dexlib2.iface.instruction.formats.*
-import org.jf.util.ExceptionWithContext
-
-fun Instruction.toBuilderInstruction() =
-    when (this.opcode.format) {
-        Format.Format10x -> InstructionConverter.newBuilderInstruction10x(this as Instruction10x)
-        Format.Format11n -> InstructionConverter.newBuilderInstruction11n(this as Instruction11n)
-        Format.Format11x -> InstructionConverter.newBuilderInstruction11x(this as Instruction11x)
-        Format.Format12x -> InstructionConverter.newBuilderInstruction12x(this as Instruction12x)
-        Format.Format20bc -> InstructionConverter.newBuilderInstruction20bc(this as Instruction20bc)
-        Format.Format21c -> InstructionConverter.newBuilderInstruction21c(this as Instruction21c)
-        Format.Format21ih -> InstructionConverter.newBuilderInstruction21ih(this as Instruction21ih)
-        Format.Format21lh -> InstructionConverter.newBuilderInstruction21lh(this as Instruction21lh)
-        Format.Format21s -> InstructionConverter.newBuilderInstruction21s(this as Instruction21s)
-        Format.Format22b -> InstructionConverter.newBuilderInstruction22b(this as Instruction22b)
-        Format.Format22c -> InstructionConverter.newBuilderInstruction22c(this as Instruction22c)
-        Format.Format22cs -> InstructionConverter.newBuilderInstruction22cs(this as Instruction22cs)
-        Format.Format22s -> InstructionConverter.newBuilderInstruction22s(this as Instruction22s)
-        Format.Format22x -> InstructionConverter.newBuilderInstruction22x(this as Instruction22x)
-        Format.Format23x -> InstructionConverter.newBuilderInstruction23x(this as Instruction23x)
-        Format.Format31c -> InstructionConverter.newBuilderInstruction31c(this as Instruction31c)
-        Format.Format31i -> InstructionConverter.newBuilderInstruction31i(this as Instruction31i)
-        Format.Format32x -> InstructionConverter.newBuilderInstruction32x(this as Instruction32x)
-        Format.Format35c -> InstructionConverter.newBuilderInstruction35c(this as Instruction35c)
-        Format.Format35mi -> InstructionConverter.newBuilderInstruction35mi(this as Instruction35mi)
-        Format.Format35ms -> InstructionConverter.newBuilderInstruction35ms(this as Instruction35ms)
-        Format.Format3rc -> InstructionConverter.newBuilderInstruction3rc(this as Instruction3rc)
-        Format.Format3rmi -> InstructionConverter.newBuilderInstruction3rmi(this as Instruction3rmi)
-        Format.Format3rms -> InstructionConverter.newBuilderInstruction3rms(this as Instruction3rms)
-        Format.Format51l -> InstructionConverter.newBuilderInstruction51l(this as Instruction51l)
-        else -> throw ExceptionWithContext("Instruction format %s not supported", this.opcode.format)
-    }
-
-internal class InstructionConverter {
-    companion object {
-        internal fun newBuilderInstruction10x(instruction: Instruction10x): BuilderInstruction10x {
-            return BuilderInstruction10x(
-                instruction.opcode
-            )
-        }
-
-        internal fun newBuilderInstruction11n(instruction: Instruction11n): BuilderInstruction11n {
-            return BuilderInstruction11n(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.narrowLiteral
-            )
-        }
-
-        internal fun newBuilderInstruction11x(instruction: Instruction11x): BuilderInstruction11x {
-            return BuilderInstruction11x(
-                instruction.opcode,
-                instruction.registerA
-            )
-        }
-
-        internal fun newBuilderInstruction12x(instruction: Instruction12x): BuilderInstruction12x {
-            return BuilderInstruction12x(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB
-            )
-        }
-
-        internal fun newBuilderInstruction20bc(instruction: Instruction20bc): BuilderInstruction20bc {
-            return BuilderInstruction20bc(
-                instruction.opcode,
-                instruction.verificationError,
-                instruction.reference
-            )
-        }
-
-        internal fun newBuilderInstruction21c(instruction: Instruction21c): BuilderInstruction21c {
-            return BuilderInstruction21c(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.reference
-            )
-        }
-
-        internal fun newBuilderInstruction21ih(instruction: Instruction21ih): BuilderInstruction21ih {
-            return BuilderInstruction21ih(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.narrowLiteral
-            )
-        }
-
-        internal fun newBuilderInstruction21lh(instruction: Instruction21lh): BuilderInstruction21lh {
-            return BuilderInstruction21lh(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.wideLiteral
-            )
-        }
-
-        internal fun newBuilderInstruction21s(instruction: Instruction21s): BuilderInstruction21s {
-            return BuilderInstruction21s(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.narrowLiteral
-            )
-        }
-
-        internal fun newBuilderInstruction22b(instruction: Instruction22b): BuilderInstruction22b {
-            return BuilderInstruction22b(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB,
-                instruction.narrowLiteral
-            )
-        }
-
-        internal fun newBuilderInstruction22c(instruction: Instruction22c): BuilderInstruction22c {
-            return BuilderInstruction22c(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB,
-                instruction.reference
-            )
-        }
-
-        internal fun newBuilderInstruction22cs(instruction: Instruction22cs): BuilderInstruction22cs {
-            return BuilderInstruction22cs(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB,
-                instruction.fieldOffset
-            )
-        }
-
-        internal fun newBuilderInstruction22s(instruction: Instruction22s): BuilderInstruction22s {
-            return BuilderInstruction22s(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB,
-                instruction.narrowLiteral
-            )
-        }
-
-        internal fun newBuilderInstruction22x(instruction: Instruction22x): BuilderInstruction22x {
-            return BuilderInstruction22x(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB
-            )
-        }
-
-        internal fun newBuilderInstruction23x(instruction: Instruction23x): BuilderInstruction23x {
-            return BuilderInstruction23x(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB,
-                instruction.registerC
-            )
-        }
-
-        internal fun newBuilderInstruction31c(instruction: Instruction31c): BuilderInstruction31c {
-            return BuilderInstruction31c(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.reference
-            )
-        }
-
-        internal fun newBuilderInstruction31i(instruction: Instruction31i): BuilderInstruction31i {
-            return BuilderInstruction31i(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.narrowLiteral
-            )
-        }
-
-        internal fun newBuilderInstruction32x(instruction: Instruction32x): BuilderInstruction32x {
-            return BuilderInstruction32x(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.registerB
-            )
-        }
-
-        internal fun newBuilderInstruction35c(instruction: Instruction35c): BuilderInstruction35c {
-            return BuilderInstruction35c(
-                instruction.opcode,
-                instruction.registerCount,
-                instruction.registerC,
-                instruction.registerD,
-                instruction.registerE,
-                instruction.registerF,
-                instruction.registerG,
-                instruction.reference
-            )
-        }
-
-        internal fun newBuilderInstruction35mi(instruction: Instruction35mi): BuilderInstruction35mi {
-            return BuilderInstruction35mi(
-                instruction.opcode,
-                instruction.registerCount,
-                instruction.registerC,
-                instruction.registerD,
-                instruction.registerE,
-                instruction.registerF,
-                instruction.registerG,
-                instruction.inlineIndex
-            )
-        }
-
-        internal fun newBuilderInstruction35ms(instruction: Instruction35ms): BuilderInstruction35ms {
-            return BuilderInstruction35ms(
-                instruction.opcode,
-                instruction.registerCount,
-                instruction.registerC,
-                instruction.registerD,
-                instruction.registerE,
-                instruction.registerF,
-                instruction.registerG,
-                instruction.vtableIndex
-            )
-        }
-
-        internal fun newBuilderInstruction3rc(instruction: Instruction3rc): BuilderInstruction3rc {
-            return BuilderInstruction3rc(
-                instruction.opcode,
-                instruction.startRegister,
-                instruction.registerCount,
-                instruction.reference
-            )
-        }
-
-        internal fun newBuilderInstruction3rmi(instruction: Instruction3rmi): BuilderInstruction3rmi {
-            return BuilderInstruction3rmi(
-                instruction.opcode,
-                instruction.startRegister,
-                instruction.registerCount,
-                instruction.inlineIndex
-            )
-        }
-
-        internal fun newBuilderInstruction3rms(instruction: Instruction3rms): BuilderInstruction3rms {
-            return BuilderInstruction3rms(
-                instruction.opcode,
-                instruction.startRegister,
-                instruction.registerCount,
-                instruction.vtableIndex
-            )
-        }
-
-        internal fun newBuilderInstruction51l(instruction: Instruction51l): BuilderInstruction51l {
-            return BuilderInstruction51l(
-                instruction.opcode,
-                instruction.registerA,
-                instruction.wideLiteral
-            )
-        }
-    }
-}

src/main/resources/revanced-patcher/version.properties

@@ -0,0 +1 @@
+version=${projectVersion}

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

@@ -0,0 +1,233 @@
+package app.revanced.patcher.extensions
+
+import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
+import app.revanced.patcher.extensions.InstructionExtensions.removeInstruction
+import app.revanced.patcher.extensions.InstructionExtensions.removeInstructions
+import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
+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 org.jf.dexlib2.Opcode
+import org.jf.dexlib2.builder.BuilderOffsetInstruction
+import org.jf.dexlib2.builder.MutableMethodImplementation
+import org.jf.dexlib2.builder.instruction.BuilderInstruction21s
+import org.jf.dexlib2.iface.instruction.OneRegisterInstruction
+import org.jf.dexlib2.immutable.ImmutableMethod
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+private object InstructionExtensionsTest {
+    private lateinit var testMethod: MutableMethod
+    private lateinit var testMethodImplementation: MutableMethodImplementation
+
+    @BeforeEach
+    fun createTestMethod() = ImmutableMethod(
+        "TestClass;",
+        "testMethod",
+        null,
+        "V",
+        AccessFlags.PUBLIC.value,
+        null,
+        null,
+        MutableMethodImplementation(16).also { testMethodImplementation = it }.apply {
+            repeat(10) { i -> this.addInstruction(TestInstruction(i)) }
+        },
+    ).let { testMethod = it.toMutable() }
+
+    @Test
+    fun addInstructionsToImplementationIndexed() = applyToImplementation {
+        addInstructions(5, getTestInstructions(5..6)).also {
+            assertRegisterIs(5, 5)
+            assertRegisterIs(6, 6)
+
+            assertRegisterIs(5, 7)
+        }
+    }
+
+    @Test
+    fun addInstructionsToImplementation() = applyToImplementation {
+        addInstructions(getTestInstructions(10..11)).also {
+            assertRegisterIs(10, 10)
+            assertRegisterIs(11, 11)
+        }
+    }
+
+    @Test
+    fun removeInstructionsFromImplementationIndexed() = applyToImplementation {
+        removeInstructions(5, 5).also { assertRegisterIs(4, 4) }
+    }
+
+    @Test
+    fun removeInstructionsFromImplementation() = applyToImplementation {
+        removeInstructions(0).also { assertRegisterIs(9, 9) }
+        removeInstructions(1).also { assertRegisterIs(1, 0) }
+        removeInstructions(2).also { assertRegisterIs(3, 0) }
+    }
+
+    @Test
+    fun replaceInstructionsInImplementationIndexed() = applyToImplementation {
+        replaceInstructions(5, getTestInstructions(0..1)).also {
+            assertRegisterIs(0, 5)
+            assertRegisterIs(1, 6)
+            assertRegisterIs(7, 7)
+        }
+    }
+
+    @Test
+    fun addInstructionToMethodIndexed() = applyToMethod {
+        addInstruction(5, TestInstruction(0)).also { assertRegisterIs(0, 5) }
+    }
+
+    @Test
+    fun addInstructionToMethod() = applyToMethod {
+        addInstruction(TestInstruction(0)).also { assertRegisterIs(0, 10) }
+    }
+
+    @Test
+    fun addSmaliInstructionToMethodIndexed() = applyToMethod {
+        addInstruction(5, getTestSmaliInstruction(0)).also { assertRegisterIs(0, 5) }
+    }
+
+    @Test
+    fun addSmaliInstructionToMethod() = applyToMethod {
+        addInstruction(getTestSmaliInstruction(0)).also { assertRegisterIs(0, 10) }
+    }
+
+    @Test
+    fun addInstructionsToMethodIndexed() = applyToMethod {
+        addInstructions(5, getTestInstructions(0..1)).also {
+            assertRegisterIs(0, 5)
+            assertRegisterIs(1, 6)
+
+            assertRegisterIs(5, 7)
+        }
+    }
+
+    @Test
+    fun addInstructionsToMethod() = applyToMethod {
+        addInstructions(getTestInstructions(0..1)).also {
+            assertRegisterIs(0, 10)
+            assertRegisterIs(1, 11)
+
+            assertRegisterIs(9, 9)
+        }
+    }
+
+    @Test
+    fun addSmaliInstructionsToMethodIndexed() = applyToMethod {
+        addInstructionsWithLabels(5, getTestSmaliInstructions(0..1)).also {
+            assertRegisterIs(0, 5)
+            assertRegisterIs(1, 6)
+
+            assertRegisterIs(5, 7)
+        }
+    }
+
+    @Test
+    fun addSmaliInstructionsToMethod() = applyToMethod {
+        addInstructions(getTestSmaliInstructions(0..1)).also {
+            assertRegisterIs(0, 10)
+            assertRegisterIs(1, 11)
+
+            assertRegisterIs(9, 9)
+        }
+    }
+
+    @Test
+    fun addSmaliInstructionsWithExternalLabelToMethodIndexed() = applyToMethod {
+        val label = ExternalLabel("testLabel", getInstruction(5))
+
+        addInstructionsWithLabels(
+            5,
+            getTestSmaliInstructions(0..1).plus("\n").plus("goto :${label.name}"),
+            label
+        ).also {
+            assertRegisterIs(0, 5)
+            assertRegisterIs(1, 6)
+            assertRegisterIs(5, 8)
+
+            val gotoTarget = getInstruction<BuilderOffsetInstruction>(7)
+                .target.location.instruction as OneRegisterInstruction
+
+            assertEquals(5, gotoTarget.registerA)
+        }
+    }
+
+    @Test
+    fun removeInstructionFromMethodIndexed() = applyToMethod {
+        removeInstruction(5).also {
+            assertRegisterIs(4, 4)
+            assertRegisterIs(6, 5)
+        }
+    }
+
+    @Test
+    fun removeInstructionsFromMethodIndexed() = applyToMethod {
+        removeInstructions(5, 5).also { assertRegisterIs(4, 4) }
+    }
+
+    @Test
+    fun removeInstructionsFromMethod() = applyToMethod {
+        removeInstructions(0).also { assertRegisterIs(9, 9) }
+        removeInstructions(1).also { assertRegisterIs(1, 0) }
+        removeInstructions(2).also { assertRegisterIs(3, 0) }
+    }
+
+    @Test
+    fun replaceInstructionInMethodIndexed() = applyToMethod {
+        replaceInstruction(5, TestInstruction(0)).also { assertRegisterIs(0, 5) }
+    }
+
+    @Test
+    fun replaceInstructionsInMethodIndexed() = applyToMethod {
+        replaceInstructions(5, getTestInstructions(0..1)).also {
+            assertRegisterIs(0, 5)
+            assertRegisterIs(1, 6)
+            assertRegisterIs(7, 7)
+        }
+    }
+
+    @Test
+    fun replaceSmaliInstructionsInMethodIndexed() = applyToMethod {
+        replaceInstructions(5, getTestSmaliInstructions(0..1)).also {
+            assertRegisterIs(0, 5)
+            assertRegisterIs(1, 6)
+            assertRegisterIs(7, 7)
+        }
+    }
+
+    // region Helper methods
+
+    private fun applyToImplementation(block: MutableMethodImplementation.() -> Unit) {
+        testMethodImplementation.apply(block)
+    }
+
+    private fun applyToMethod(block: MutableMethod.() -> Unit) {
+        testMethod.apply(block)
+    }
+
+    private fun MutableMethodImplementation.assertRegisterIs(register: Int, atIndex: Int) = assertEquals(
+        register, getInstruction<OneRegisterInstruction>(atIndex).registerA
+    )
+
+    private fun MutableMethod.assertRegisterIs(register: Int, atIndex: Int) =
+        implementation!!.assertRegisterIs(register, atIndex)
+
+    private fun getTestInstructions(range: IntRange) = range.map { TestInstruction(it) }
+
+    private fun getTestSmaliInstruction(register: Int) = "const/16 v$register, 0"
+
+    private fun getTestSmaliInstructions(range: IntRange) = range.joinToString("\n") {
+        getTestSmaliInstruction(it)
+    }
+
+    // endregion
+
+    private class TestInstruction(register: Int) : BuilderInstruction21s(Opcode.CONST_16, register, 0)
+}

src/test/kotlin/app/revanced/patcher/issues/Issue98.kt

@@ -0,0 +1,18 @@
+package app.revanced.patcher.issues
+
+import app.revanced.patcher.patch.PatchOption
+import org.junit.jupiter.api.Test
+import kotlin.test.assertNull
+
+internal class Issue98 {
+    companion object {
+        var key1: String? by PatchOption.StringOption(
+            "key1", null, "title", "description"
+        )
+    }
+
+    @Test
+    fun `should infer nullable type correctly`() {
+        assertNull(key1)
+    }
+}

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

@@ -0,0 +1,107 @@
+package app.revanced.patcher.patch
+
+import app.revanced.patcher.usage.bytecode.ExampleBytecodePatch
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertNotEquals
+
+internal class PatchOptionsTest {
+    private val options = ExampleBytecodePatch.options
+
+    @Test
+    fun `should not throw an exception`() {
+        for (option in options) {
+            when (option) {
+                is PatchOption.StringOption -> {
+                    option.value = "Hello World"
+                }
+
+                is PatchOption.BooleanOption -> {
+                    option.value = false
+                }
+
+                is PatchOption.StringListOption -> {
+                    option.value = option.options.first()
+                    for (choice in option.options) {
+                        println(choice)
+                    }
+                }
+
+                is PatchOption.IntListOption -> {
+                    option.value = option.options.first()
+                    for (choice in option.options) {
+                        println(choice)
+                    }
+                }
+            }
+        }
+        val option = options.get<String>("key1")
+        // or: val option: String? by options["key1"]
+        // then you won't need `.value` every time
+        println(option.value)
+        options["key1"] = "Hello, world!"
+        println(option.value)
+    }
+
+    @Test
+    fun `should return a different value when changed`() {
+        var value: String? by options["key1"]
+        val current = value + "" // force a copy
+        value = "Hello, world!"
+        assertNotEquals(current, value)
+    }
+
+    @Test
+    fun `should be able to set value to null`() {
+        // Sadly, doing:
+        // > options["key2"] = null
+        // is not possible because Kotlin
+        // cannot reify the type "Nothing?".
+        // So we have to do this instead:
+        options["key2"] = null as Any?
+        // This is a cleaner replacement for the above:
+        options.nullify("key2")
+    }
+
+    @Test
+    fun `should fail because the option does not exist`() {
+        assertThrows<NoSuchOptionException> {
+            options["this option does not exist"] = 123
+        }
+    }
+
+    @Test
+    fun `should fail because of invalid value type when setting an option`() {
+        assertThrows<InvalidTypeException> {
+            options["key1"] = 123
+        }
+    }
+
+    @Test
+    fun `should fail because of invalid value type when getting an option`() {
+        assertThrows<InvalidTypeException> {
+            options.get<Int>("key1")
+        }
+    }
+
+    @Test
+    fun `should fail because of an illegal value`() {
+        assertThrows<IllegalValueException> {
+            options["key3"] = "this value is not an allowed option"
+        }
+    }
+
+    @Test
+    fun `should fail because the requirement is not met`() {
+        assertThrows<RequirementNotMetException> {
+            options.nullify("key1")
+        }
+    }
+
+    @Test
+    fun `should fail because getting a non-initialized option is illegal`() {
+        assertThrows<RequirementNotMetException> {
+            println(options["key5"].value)
+        }
+    }
+}

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

@@ -1,46 +0,0 @@
-package app.revanced.patcher.usage
-
-import org.junit.jupiter.api.Test
-
-internal class PatcherTest {
-    @Test
-    fun testPatcher() {
-        return // FIXME: create a proper resource to pass this test
-        /**
-        val patcher = Patcher(
-        File(PatcherTest::class.java.getResource("/example.apk")!!.toURI()),
-        "exampleCacheDirectory",
-        patchResources = true
-        )
-
-        patcher.addPatches(listOf(ExampleBytecodePatch(), ExampleResourcePatch()))
-
-        for (signature in patcher.resolveSignatures()) {
-        if (!signature.resolved) {
-        throw Exception("Signature ${signature.metadata.name} was not resolved!")
-        }
-        val patternScanMethod = signature.metadata.patternScanMethod
-        if (patternScanMethod is PatternScanMethod.Fuzzy) {
-        val warnings = patternScanMethod.warnings
-        if (warnings != null) {
-        println("Signature ${signature.metadata.name} had ${warnings.size} warnings!")
-        for (warning in warnings) {
-        println(warning.toString())
-        }
-        } else {
-        println("Signature ${signature.metadata.name} used the fuzzy resolver, but the warnings list is null!")
-        }
-        }
-        }
-        for ((metadata, result) in patcher.applyPatches()) {
-        if (result.isFailure) {
-        throw Exception("Patch ${metadata.shortName} failed", result.exceptionOrNull()!!)
-        } else {
-        println("Patch ${metadata.shortName} applied successfully!")
-        }
-        }
-        val out = patcher.save()
-        assertTrue(out.isNotEmpty(), "Expected the output of Patcher#save() to not be empty.")
-         */
-    }
-}

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

@@ -1,4 +1,4 @@
-package app.revanced.patcher.usage.bytecode.annotation
+package app.revanced.patcher.usage.bytecode
 
 import app.revanced.patcher.annotation.Compatibility
 import app.revanced.patcher.annotation.Package
@@ -9,6 +9,5 @@ import app.revanced.patcher.annotation.Package
     )]
 )
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
 internal annotation class ExampleBytecodeCompatibility
 

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

@@ -1,20 +1,19 @@
-package app.revanced.patcher.usage.bytecode.patch
+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.impl.BytecodeData
-import app.revanced.patcher.extensions.addInstructions
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
 import app.revanced.patcher.extensions.or
-import app.revanced.patcher.patch.PatchResult
-import app.revanced.patcher.patch.PatchResultSuccess
+import app.revanced.patcher.patch.*
+import app.revanced.patcher.patch.annotations.DependsOn
 import app.revanced.patcher.patch.annotations.Patch
-import app.revanced.patcher.patch.impl.BytecodePatch
-import app.revanced.patcher.usage.bytecode.fingerprints.ExampleFingerprint
 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 app.revanced.patcher.util.smali.toInstruction
 import com.google.common.collect.ImmutableList
 import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Format
@@ -36,13 +35,18 @@ import org.jf.dexlib2.util.Preconditions
 @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(data: BytecodeData): PatchResult {
+    override fun execute(context: BytecodeContext): PatchResult {
         // Get the resolved method by its fingerprint from the resolver cache
         val result = ExampleFingerprint.result!!
 
+        // Patch options
+        println(key1)
+        key2 = false
+
         // Get the implementation for the resolved method
         val method = result.mutableMethod
         val implementation = method.implementation!!
@@ -50,14 +54,14 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
         // Let's modify it, so it prints "Hello, ReVanced! Editing bytecode."
         // Get the start index of our opcode pattern.
         // This will be the index of the instruction with the opcode CONST_STRING.
-        val startIndex = result.patternScanResult!!.startIndex
+        val startIndex = result.scanResult.patternScanResult!!.startIndex
 
         implementation.replaceStringAt(startIndex, "Hello, ReVanced! Editing bytecode.")
 
         // Get the class in which the method matching our fingerprint is defined in.
-        val mainClass = data.findClass {
+        val mainClass = context.findClass {
             it.type == result.classDef.type
-        }!!.resolve()
+        }!!.mutableClass
 
         // Add a new method returning a string
         mainClass.methods.add(
@@ -107,22 +111,21 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
         )
 
         // store the fields initial value into the first virtual register
-        implementation.replaceInstruction(
-            0,
-            "sget-object v0, LTestClass;->dummyField:Ljava/io/PrintStream;".toInstruction()
-        )
+        method.replaceInstruction(0, "sget-object v0, LTestClass;->dummyField:Ljava/io/PrintStream;")
 
         // Now let's create a new call to our method and print the return value!
         // You can also use the smali compiler to create instructions.
         // For this sake of example I reuse the TestClass field dummyField inside the virtual register 0.
         //
         // Control flow instructions are not supported as of now.
-        val instructions = """
-                        invoke-static { }, LTestClass;->returnHello()Ljava/lang/String;
-                        move-result-object v1
-                        invoke-virtual { v0, v1 }, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
-                    """
-        method.addInstructions(startIndex + 2, instructions)
+        method.addInstructionsWithLabels(
+            startIndex + 2,
+            """
+                invoke-static { }, LTestClass;->returnHello()Ljava/lang/String;
+                move-result-object v1
+                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.
@@ -161,4 +164,33 @@ class ExampleBytecodePatch : BytecodePatch(listOf(ExampleFingerprint)) {
             )
         )
     }
+
+    @Suppress("unused")
+    companion object : OptionsContainer() {
+        private var key1 by option(
+            PatchOption.StringOption(
+                "key1", "default", "title", "description", true
+            )
+        )
+        private var key2 by option(
+            PatchOption.BooleanOption(
+                "key2", true, "title", "description" // required defaults to false
+            )
+        )
+        private var key3 by option(
+            PatchOption.StringListOption(
+                "key3", "TEST", listOf("TEST", "TEST1", "TEST2"), "title", "description"
+            )
+        )
+        private var key4 by option(
+            PatchOption.IntListOption(
+                "key4", 1, listOf(1, 2, 3), "title", "description"
+            )
+        )
+        private var key5 by option(
+            PatchOption.StringOption(
+                "key5", null, "title", "description", true
+            )
+        )
+    }
 }

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

@@ -1,23 +1,11 @@
-package app.revanced.patcher.usage.bytecode.fingerprints
-
-import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.annotation.Version
+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.annotation.MatchingMethod
 import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-import app.revanced.patcher.usage.bytecode.annotation.ExampleBytecodeCompatibility
 import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Opcode
 
-@Name("example-fingerprint")
-@MatchingMethod(
-    "LexampleClass;",
-    "exampleMehod"
-)
 @FuzzyPatternScanMethod(2)
-@ExampleBytecodeCompatibility
-@Version("0.0.1")
 object ExampleFingerprint : MethodFingerprint(
     "V",
     AccessFlags.PUBLIC or AccessFlags.STATIC,

src/test/kotlin/app/revanced/patcher/usage/resource/annotation/ExampleResourceCompatibility.kt

@@ -9,6 +9,5 @@ import app.revanced.patcher.annotation.Package
     )]
 )
 @Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.RUNTIME)
 internal annotation class ExampleResourceCompatibility
 

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

@@ -3,11 +3,11 @@ 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.impl.ResourceData
+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.patch.impl.ResourcePatch
 import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
 import org.w3c.dom.Element
 
@@ -16,9 +16,9 @@ import org.w3c.dom.Element
 @Description("Example demonstration of a resource patch.")
 @ExampleResourceCompatibility
 @Version("0.0.1")
-class ExampleResourcePatch : ResourcePatch() {
-    override fun execute(data: ResourceData): PatchResult {
-        data.xmlEditor["AndroidManifest.xml"].use { editor ->
+class ExampleResourcePatch : ResourcePatch {
+    override fun execute(context: ResourceContext): PatchResult {
+        context.xmlEditor["AndroidManifest.xml"].use { editor ->
             val element = editor // regular DomFileEditor
                 .file
                 .getElementsByTagName("application")

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

@@ -0,0 +1,105 @@
+package app.revanced.patcher.util.smali
+
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+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 org.jf.dexlib2.Opcode
+import org.jf.dexlib2.builder.BuilderInstruction
+import org.jf.dexlib2.builder.MutableMethodImplementation
+import org.jf.dexlib2.builder.instruction.BuilderInstruction21c
+import org.jf.dexlib2.builder.instruction.BuilderInstruction21t
+import org.jf.dexlib2.immutable.ImmutableMethod
+import org.jf.dexlib2.immutable.reference.ImmutableStringReference
+import java.util.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+internal class InlineSmaliCompilerTest {
+    @Test
+    fun `compiler should output valid instruction`() {
+        val want = BuilderInstruction21c(Opcode.CONST_STRING, 0, ImmutableStringReference("Test")) as BuilderInstruction
+        val have = "const-string v0, \"Test\"".toInstruction()
+        instructionEquals(want, have)
+    }
+
+    @Test
+    fun `compiler should support branching with own branches`() {
+        val method = createMethod()
+        val insnAmount = 8
+        val insnIndex = insnAmount - 2
+        val targetIndex = insnIndex - 1
+
+        method.addInstructions(arrayOfNulls<String>(insnAmount).also {
+            Arrays.fill(it, "const/4 v0, 0x0")
+        }.joinToString("\n"))
+        method.addInstructionsWithLabels(
+            targetIndex,
+            """
+                :test
+                const/4 v0, 0x1
+                if-eqz v0, :test
+            """
+        )
+
+        val insn = method.getInstruction<BuilderInstruction21t>(insnIndex)
+        assertEquals(targetIndex, insn.target.location.index)
+    }
+
+    @Test
+    fun `compiler should support branching to outside branches`() {
+        val method = createMethod()
+        val insnIndex = 3
+        val labelIndex = 1
+
+        method.addInstructions(
+            """
+                const/4 v0, 0x1
+                const/4 v0, 0x0
+            """
+        )
+
+        assertEquals(labelIndex, method.newLabel(labelIndex).location.index)
+
+        method.addInstructionsWithLabels(
+            method.implementation!!.instructions.size,
+            """
+                const/4 v0, 0x1
+                if-eqz v0, :test
+                return-void
+            """,
+            ExternalLabel("test", method.getInstruction(1))
+        )
+
+        val insn = method.getInstruction<BuilderInstruction21t>(insnIndex)
+        assertTrue(insn.target.isPlaced, "Label was not placed")
+        assertEquals(labelIndex, insn.target.location.index)
+    }
+
+    companion object {
+        private fun createMethod(
+            name: String = "dummy",
+            returnType: String = "V",
+            accessFlags: Int = AccessFlags.STATIC.value,
+            registerCount: Int = 1,
+        ) = ImmutableMethod(
+            "Ldummy;",
+            name,
+            emptyList(), // parameters
+            returnType,
+            accessFlags,
+            emptySet(),
+            emptySet(),
+            MutableMethodImplementation(registerCount)
+        ).toMutable()
+
+        private fun instructionEquals(want: BuilderInstruction, have: BuilderInstruction) {
+            assertEquals(want.opcode, have.opcode)
+            assertEquals(want.format, have.format)
+            assertEquals(want.codeUnits, have.codeUnits)
+        }
+    }
+}