chore(release): 1.2.2 [skip ci]

## [1.2.2](https://github.com/revanced/revanced-patcher/compare/v1.2.1...v1.2.2) (2022-06-14)

### Bug Fixes

* enforce aapt v2 ([b68b0bf](b68b0bf3d7))

.github/workflows/release.yml

@@ -1,5 +1,6 @@
 name: Release
 on:
+  workflow_dispatch:
   push:
     branches:
       - main
@@ -20,7 +21,7 @@ jobs:
       - name: Setup JDK
         uses: actions/setup-java@v2
         with:
-          java-version: '8'
+          java-version: '17'
           distribution: 'adopt'
           cache: gradle
       - name: Setup Node.js

.idea/misc.xml

@@ -4,7 +4,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <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>

CHANGELOG.md

@@ -1,3 +1,238 @@
+## [1.2.2](https://github.com/revanced/revanced-patcher/compare/v1.2.1...v1.2.2) (2022-06-14)
+
+
+### Bug Fixes
+
+* enforce aapt v2 ([b68b0bf](https://github.com/revanced/revanced-patcher/commit/b68b0bf3d735f54b92ad7dad8132f77e9007063f))
+
+## [1.2.1](https://github.com/revanced/revanced-patcher/compare/v1.2.0...v1.2.1) (2022-06-14)
+
+
+### Bug Fixes
+
+* Patcher setting BuildOptions too late ([6a5c873](https://github.com/revanced/revanced-patcher/commit/6a5c8735fb8a5d6f7e9c606734b6684c7fa99e7f))
+
+# [1.2.0](https://github.com/revanced/revanced-patcher/compare/v1.1.0...v1.2.0) (2022-06-14)
+
+
+### Features
+
+* allow custom framework path to be specified ([d3a580e](https://github.com/revanced/revanced-patcher/commit/d3a580ea19d7c2d5d8c97650b1e6396ea0a7fc25))
+
+# [1.1.0](https://github.com/revanced/revanced-patcher/compare/v1.0.0...v1.1.0) (2022-06-11)
+
+
+### Bug Fixes
+
+* resource patcher ([31815ca](https://github.com/revanced/revanced-patcher/commit/31815ca9ea990f16b3600d61fd570c1805be1c82))
+* update apktool to fork ([566ecef](https://github.com/revanced/revanced-patcher/commit/566ecefa2bd4cde5ebfb2b22dc56cd8bf9f396bd))
+
+
+### Features
+
+* allow custom aapt path to be specified ([8eb4a8f](https://github.com/revanced/revanced-patcher/commit/8eb4a8f87ae7679a272f3224273a37a31d4bb121))
+
+# 1.0.0 (2022-06-05)
+
+
+### Bug Fixes
+
+* `compareSignatureToMethod` not matching correctly in case opcodes are null ([cca12aa](https://github.com/revanced/revanced-patcher/commit/cca12aa34a60d766c02e55241df847f7d230d4d7))
+* `ConcurrentModificationException` while iterating through `proxies` and modifying it ([6cb7cdb](https://github.com/revanced/revanced-patcher/commit/6cb7cdb0b2a2b954adb04033e0f2d3ccb4604545))
+* `JarPatchBundle` loading non-class files to class loader ([849616d](https://github.com/revanced/revanced-patcher/commit/849616dc2b6e30ec1fa1d8a8f9c1f881fc11676a))
+* `PackageMetadata` ([7399450](https://github.com/revanced/revanced-patcher/commit/739945013962fd80d2635fff126d84046870f956))
+* `replaceWith` not replacing classes with used class proxies ([4178a1e](https://github.com/revanced/revanced-patcher/commit/4178a1eedce1436ffeb3ddd6952ce0b6ec87d5a0))
+* adding existing classes to the patchers cache ([9659a61](https://github.com/revanced/revanced-patcher/commit/9659a61c5c3a84714160b78b32cc337a97c8caa9))
+* always return PatchResultSuccess on patch success ([996c4ac](https://github.com/revanced/revanced-patcher/commit/996c4acb2061db776430ad8b07bfdb3fe32861f6))
+* applying no patches throwing error ([5ca5a1c](https://github.com/revanced/revanced-patcher/commit/5ca5a1c29e087ce7e4b6d5e593b775365803151d))
+* applyPatches not returning successful patches ([f806cb3](https://github.com/revanced/revanced-patcher/commit/f806cb38c571cdd22016396ee1874ee18c91b79f))
+* avoid ignoring test resources (fixes [#1](https://github.com/revanced/revanced-patcher/issues/1)) ([d5a3c76](https://github.com/revanced/revanced-patcher/commit/d5a3c76389ba902c22ddc8b7ba1a110b7ff852df))
+* Classes not being written properly because of array shifting ([6e4db11](https://github.com/revanced/revanced-patcher/commit/6e4db110c8fdd16fb0c0ce81f427d84f2a3b6ee0))
+* current must be calculated after increment ([5f12bab](https://github.com/revanced/revanced-patcher/commit/5f12bab5df97fbe6e2e62c1bf2814a2e682ab4f3))
+* failing tests temporarily ([fc05fe7](https://github.com/revanced/revanced-patcher/commit/fc05fe79deec2486bb746d33e803ad052e68f8de))
+* fix classes having multiple instances of fields ([7cc8a7d](https://github.com/revanced/revanced-patcher/commit/7cc8a7dec321774c1d3f2f1a87ac91f952c4fb7e))
+* fix classes having multiple method instances ([398239d](https://github.com/revanced/revanced-patcher/commit/398239dc10a3ea04e46adb3be176c897876e5587))
+* Fixed writer & signature resolver, improved tests & speed, minor refactoring ([e6c2501](https://github.com/revanced/revanced-patcher/commit/e6c2501539540301d5b70014de460e5452a09b04))
+* fuzzy resolver warning params were turned around ([e5bea06](https://github.com/revanced/revanced-patcher/commit/e5bea06353805f004d607124a8ebed138f84d583))
+* give ClassWriter a ClassReader for symtable ([41749ba](https://github.com/revanced/revanced-patcher/commit/41749ba8290b2dec5dd2ab6e0bc9d714887a1a05))
+* **gradle:** publish source and javadocs ([c236ebe](https://github.com/revanced/revanced-patcher/commit/c236ebe0789f9c78d610769f0feda2b64fa4a128))
+* incorrect pattern offset ([f3b5f67](https://github.com/revanced/revanced-patcher/commit/f3b5f67b395167c1b9411b2374f3ef584b57b6cf))
+* **Io:** fix finding classes by name ([b957501](https://github.com/revanced/revanced-patcher/commit/b957501e709028005c4d6c7857022980205b6861))
+* **Io:** JAR loading and saving ([#8](https://github.com/revanced/revanced-patcher/issues/8)) ([310a7c4](https://github.com/revanced/revanced-patcher/commit/310a7c446b547d84b02c5da2161958e77ce69f0d))
+* make `methodMetadata` nullable in `MethodSignatureMetadata` ([4e56652](https://github.com/revanced/revanced-patcher/commit/4e566524299674426fb0344d09db3b0c1cb3d300))
+* make warnings nullable instead of lateinit ([8f1a629](https://github.com/revanced/revanced-patcher/commit/8f1a629191668e05917dc797e486647e55276d59))
+* match to correct signature method parameters ([1ee2e4b](https://github.com/revanced/revanced-patcher/commit/1ee2e4ba56097c5e06c93c9ce04cb5543f0e4a67))
+* **MethodResolver:** fix cd57a8c9a0db7e3ae5ad0bca202e5955930319ab ([cbd8df2](https://github.com/revanced/revanced-patcher/commit/cbd8df2df008ef37c6b43e2a8442c41f24be9358))
+* **MethodResolver:** strip labels and line numbers so opcode patterns match ([699c730](https://github.com/revanced/revanced-patcher/commit/699c730a7cecf31878827d645e845490a37de4cb))
+* **MethodResolver:** strip labels nodes so opcode patterns match ([82c5306](https://github.com/revanced/revanced-patcher/commit/82c530650f926dd026d263cfe23a7d67cb27bbf2))
+* MethodSignature#resolved throwing an exception ([c612676](https://github.com/revanced/revanced-patcher/commit/c612676543282155143471b71a095e26023806ea))
+* Move proxy package out of cache package ([ce21bd6](https://github.com/revanced/revanced-patcher/commit/ce21bd60f34d78b94d6d85f2c5375bc934ed4091))
+* null check causing an exception ([338bd9f](https://github.com/revanced/revanced-patcher/commit/338bd9f7394afd84e5e195a7f8155c813812cfb5))
+* nullable signature members ([#10](https://github.com/revanced/revanced-patcher/issues/10)) ([674461f](https://github.com/revanced/revanced-patcher/commit/674461f08daabbf92cb54e4eadb408226fac47af))
+* Patch should have access to the Cache ([4dd820f](https://github.com/revanced/revanced-patcher/commit/4dd820ffdf1b98fe41b50f7cb2670b89acfbb99d))
+* Patcher not writing resolved methods ([fac44a5](https://github.com/revanced/revanced-patcher/commit/fac44a50c39d8c102bd3e7ca4dd1bb86d29f7b57))
+* qualifying `Element` with wrong package ([024fa86](https://github.com/revanced/revanced-patcher/commit/024fa867e115f984cfa3e395b78f4f43aa81709b))
+* reaching all constructors not possible ([c459beb](https://github.com/revanced/revanced-patcher/commit/c459beb5f898d797f2f03ed36326bd9cfad03d31))
+* reformat (trigger release) ([bf48945](https://github.com/revanced/revanced-patcher/commit/bf4894592bf9ee9c6233abc91f538b7b8ef986a0))
+* remove broken code ([0e72a6e](https://github.com/revanced/revanced-patcher/commit/0e72a6e85ff9a6035510680fc5e33ab0cd14144f))
+* remove dependency to fork of Apktool ([11abc67](https://github.com/revanced/revanced-patcher/commit/11abc67d9ab7d7b273fd4cd4c53af54008a80585))
+* remove leftover debug code ([0f30eac](https://github.com/revanced/revanced-patcher/commit/0f30eac32ce66d8b90906c02ef7e7854feeecc33))
+* return mutable set of classes ([66a9b76](https://github.com/revanced/revanced-patcher/commit/66a9b768457e98fdde0b61f9a8d6aed4c1872027))
+* returning failure on success ([48c4ea2](https://github.com/revanced/revanced-patcher/commit/48c4ea2f6d9de319383a49ea2d4c6ffb4f687a2b))
+* Search method map for existing class proxy ([a1e909b](https://github.com/revanced/revanced-patcher/commit/a1e909b16337c538f8f8b475801d8b1804163bfe))
+* set index for insertAt to 0 by default ([d5b4c99](https://github.com/revanced/revanced-patcher/commit/d5b4c99c00272e3e5afec2fa0a489ba618f2a81a))
+* set marklimit to Integer.MAX_VALUE ([e6e468f](https://github.com/revanced/revanced-patcher/commit/e6e468fbb5c20b08c8bd59bafc794acea907e4b4))
+* string signature in `SignatureResolver` ([e5ae970](https://github.com/revanced/revanced-patcher/commit/e5ae9700096924e63b15a08079dce40ae07202d8))
+* Suppress unused for addFiles ([3d6a1d3](https://github.com/revanced/revanced-patcher/commit/3d6a1d38f339ce2c5d82b7ac46c208c6702d6d44))
+* throwing in case the opcode patterns do not match ([3144ec8](https://github.com/revanced/revanced-patcher/commit/3144ec872ac8651b8c0a9311ae508d5c3cc734ce))
+* use Array instead of Iterable for methodParameters ([dfac8f0](https://github.com/revanced/revanced-patcher/commit/dfac8f03a362fd273527f552d9eae121505fd4e0))
+* using old instance of `Androlib` when saving ([a4d8be2](https://github.com/revanced/revanced-patcher/commit/a4d8be20fcd444b08ec9c43f9f7029f8bacbbc41))
+* workflow on dev branch ([428f7f4](https://github.com/revanced/revanced-patcher/commit/428f7f4decb00d28c9bf137ef4cd1d5fd4a0821e))
+* write all classes ([f068fc8](https://github.com/revanced/revanced-patcher/commit/f068fc87ff8e204826639318af39e48e683254da))
+
+
+### Code Refactoring
+
+* bump multidexlib2 to 2.5.2.r2 ([a6c6b49](https://github.com/revanced/revanced-patcher/commit/a6c6b4979af42936cb26608541a4f7a66393b3f0))
+* Change all references from Array to Iterable ([72f3cad](https://github.com/revanced/revanced-patcher/commit/72f3cad3f98001b0109b07373ed9cc57a9001cfa))
+* convert Patch to abstract class ([cb9b1b9](https://github.com/revanced/revanced-patcher/commit/cb9b1b9416c699c68d0fca228d4f8ca6fb634cb5))
+* Optimize Signature class ([#11](https://github.com/revanced/revanced-patcher/issues/11)) ([7faa001](https://github.com/revanced/revanced-patcher/commit/7faa001406c1f28dc2182cf6d1ab19504f4e3eb9))
+* Rename `net.revanced` to `app.revanced` ([7087230](https://github.com/revanced/revanced-patcher/commit/70872307e33282b37dd5fb315b56022ab73bf582))
+
+
+### Features
+
+* `Dependencies` annotation ([893d4c6](https://github.com/revanced/revanced-patcher/commit/893d4c699bad4c70002fc691c261447d01948b5c))
+* `PatchLoader` ([ec9fd15](https://github.com/revanced/revanced-patcher/commit/ec9fd15f9b9b9968be7fb5cb384eb8ee2a0c9ba3))
+* Add `findParentMethod` utility method ([#4](https://github.com/revanced/revanced-patcher/issues/4)) ([bbb2c54](https://github.com/revanced/revanced-patcher/commit/bbb2c547aae8dd774a1a883de24fe45da463fa35))
+* add `MethodWalker` ([7755bbc](https://github.com/revanced/revanced-patcher/commit/7755bbc645773e49053fb9ad2b6fd18a7f488659))
+* add `p` naming scheme to smali compiler ([79909cf](https://github.com/revanced/revanced-patcher/commit/79909cf260c0578e88ad22d63397957dbaa91702))
+* add extensions for cloning methods ([01bfbd6](https://github.com/revanced/revanced-patcher/commit/01bfbd656ee06cb2cab951c43d7f76a465a40830))
+* add findClass method with className ([4087f49](https://github.com/revanced/revanced-patcher/commit/4087f498638ee88ba3eaca792039fe481f404732))
+* Add first tests ([544bcf7](https://github.com/revanced/revanced-patcher/commit/544bcf76bd8a8c790c2f799606ad8c9ac7d2aa82))
+* add fuzzy resolver ([7a56dca](https://github.com/revanced/revanced-patcher/commit/7a56dca004cd793121a59ea854c77f4c1a01bd6f))
+* add immutableMethod ([c63b20f](https://github.com/revanced/revanced-patcher/commit/c63b20fa65aba8bb060a4a7a652747cba7198c2b))
+* add inline smali compiler ([bfe4e3e](https://github.com/revanced/revanced-patcher/commit/bfe4e3e298ac963936ca9621e12aefbe56260826))
+* add missing test for fields ([6b8b057](https://github.com/revanced/revanced-patcher/commit/6b8b0573d479e227b45dc36a6abac622c3ccebdd))
+* add or extension for AccessFlags ([00c85b5](https://github.com/revanced/revanced-patcher/commit/00c85b5d750ccc8de69ad4101220b19eeaf99bcb))
+* Add patch metadata ([642e903](https://github.com/revanced/revanced-patcher/commit/642e9031eb3727ebdca22c75b7c5c602a8775da0)), closes [ReVancedTeam/revanced-patches#1](https://github.com/ReVancedTeam/revanced-patches/issues/1)
+* add SafeClassWriter ([6626014](https://github.com/revanced/revanced-patcher/commit/6626014ef3dde2f98a53f75d71eeb0de85189bf3))
+* Add warnings for Fuzzy resolver ([715a2ad](https://github.com/revanced/revanced-patcher/commit/715a2ad025d127b5a8225ce50202a859f53c7f50))
+* allow classes to be overwritten in addFiles and resolve signatures when applyPatches is called ([1db735b](https://github.com/revanced/revanced-patcher/commit/1db735b1e2b570bdb1ddce0b9cd724c580113a84))
+* Allow unknown opcodes using `null` ([0e5f4ba](https://github.com/revanced/revanced-patcher/commit/0e5f4ba2d55288415c4d1be70ab6a8ab8c1c0d10))
+* Finish first patcher test ([0d8d19e](https://github.com/revanced/revanced-patcher/commit/0d8d19e708a47315e28e7493618568ea40f1e062))
+* Improve `SignatureResolver` ([139a23b](https://github.com/revanced/revanced-patcher/commit/139a23b7500a2d2577df47caf3fd0c5ec891a8d8))
+* migrate to `DexPatchBundle` and `JarPatchBundle` ([8615798](https://github.com/revanced/revanced-patcher/commit/8615798711185b30ce622d9d09faba21f3a92f97))
+* migrate to dexlib ([3651981](https://github.com/revanced/revanced-patcher/commit/36519811610192e299834e9d00627a94faad56a9))
+* Minor refactor and return proxy, if class has been proxied already ([4b26305](https://github.com/revanced/revanced-patcher/commit/4b26305bd57ba9e3eb3e34218ffe10d6c5a2f598))
+* optional `forStaticMethod` parameter for `InlineSmaliCompiler.compileMethodInstructions` ([41e8860](https://github.com/revanced/revanced-patcher/commit/41e88605c33d1f0d9e7f5466cac03a3b339afb82))
+* patch dependencies annotation and `PatcherOptions` ([6c65952](https://github.com/revanced/revanced-patcher/commit/6c65952d80a795a3ef4a37877123e9375025d3ae))
+* properly manage `ClassProxy` & add `ProxyBackedClassList` ([6cb1fdf](https://github.com/revanced/revanced-patcher/commit/6cb1fdf6171e1ab75b7ee28163965eacc00cc5a0))
+* remaining mutable `EncodedValue` classes ([3f97cc8](https://github.com/revanced/revanced-patcher/commit/3f97cc8e1fa10546d7069e01e5e66a537b0d6f7e))
+* string signature ([#22](https://github.com/revanced/revanced-patcher/issues/22)) ([612515a](https://github.com/revanced/revanced-patcher/commit/612515acf8539febf952f258d30aa3d4b631e3b7))
+* use annotations instead of metadata objects ([d20f7fd](https://github.com/revanced/revanced-patcher/commit/d20f7fd6e1ede6ec7baccb1500ab3fc66d78df73))
+* utility functions to get metadata of patch & sigs ([54511a4](https://github.com/revanced/revanced-patcher/commit/54511a4fc6417d7fe0c868d441e7d6b0ec9e218d))
+
+
+### Performance Improvements
+
+* check type instead of class ([c7ef264](https://github.com/revanced/revanced-patcher/commit/c7ef2644d83e1d8e84decb0631a6549d394180fc))
+* decode manifest only when not using resource patcher ([4f60bea](https://github.com/revanced/revanced-patcher/commit/4f60bea81e0bbe85dc6c3150238980292a1e52ab))
+* depend on `androlib` instead of `ApkDecoder` ([cc9416d](https://github.com/revanced/revanced-patcher/commit/cc9416dd11b66140c2882021cbe5088659d85371))
+* do not resolve empty signatures list ([b1eebc9](https://github.com/revanced/revanced-patcher/commit/b1eebc99a71269df33c37f35c1f56ea20a9d6bc0))
+* lazy-ify all mutable clones ([d18a3b6](https://github.com/revanced/revanced-patcher/commit/d18a3b6a28cae4fcb1c4986903208298ee50b083))
+* optimize indexOf call away ([9991f39](https://github.com/revanced/revanced-patcher/commit/9991f39c9a4fa22a221aab0bbf9e08ca7f967fa9))
+* use Set instead of List since there are no dupes ([e65ebd2](https://github.com/revanced/revanced-patcher/commit/e65ebd27c250b1735acf73af0f6b03274b0137f6))
+* use String List and compare instead of any lambda ([5bd416b](https://github.com/revanced/revanced-patcher/commit/5bd416b409290906a6378344f70391e8692ae27f))
+
+
+### Reverts
+
+* AccessFlag extensions not working with IDE ([0bfb92a](https://github.com/revanced/revanced-patcher/commit/0bfb92a0cbd72df5ba513264efb583e201cfcf82))
+* previous commits check for dupes in dexFile, not cache ([e810197](https://github.com/revanced/revanced-patcher/commit/e810197e2aa64534f2e8637165d884cbefbce8ae))
+
+
+### BREAKING CHANGES
+
+* arrayOf has to be changed to listOf.
+* Method signature of Patcher#save() was changed to comply with the changes of multidexlib2.
+* Removed usage of ASM library
+* Array<Int> was changed to IntArray. This breaks existing patches.
+* Package name was changed from "net.revanced" to "app.revanced"
+* Method signature of execute() was changed to include the cache, this will break existing implementations of the Patch class.
+* Patch class is now an abstract class. You must implement it. You can use anonymous implements, like done in the tests.
+
+# [1.0.0-dev.18](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.17...v1.0.0-dev.18) (2022-06-04)
+
+
+### Features
+
+* `Dependencies` annotation ([83d608a](https://github.com/revanced/revanced-patcher/commit/83d608ac06a7d5ceb31b6e0022b501d99edb63a3))
+* optional `forStaticMethod` parameter for `InlineSmaliCompiler.compileMethodInstructions` ([28b9847](https://github.com/revanced/revanced-patcher/commit/28b98478e4e8e8f238e82f7fa2307aeb1547955d))
+
+# [1.0.0-dev.17](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.16...v1.0.0-dev.17) (2022-05-31)
+
+
+### Features
+
+* patch dependencies annotation and `PatcherOptions` ([8442991](https://github.com/revanced/revanced-patcher/commit/84429912900872405b44804943357dda8430a550))
+
+# [1.0.0-dev.16](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.15...v1.0.0-dev.16) (2022-05-27)
+
+
+### Bug Fixes
+
+* `JarPatchBundle` loading non-class files to class loader ([3f0c740](https://github.com/revanced/revanced-patcher/commit/3f0c740200dd91a060426638c2f8f516938b4c53))
+* remove dependency to fork of Apktool ([0fa529f](https://github.com/revanced/revanced-patcher/commit/0fa529fcdf9a7b5ea9a361b9f9f32f3f3fce009f))
+
+
+### Features
+
+* migrate to `DexPatchBundle` and `JarPatchBundle` ([7573db2](https://github.com/revanced/revanced-patcher/commit/7573db25757de89824af4f3aea167e500120eabb))
+
+# [1.0.0-dev.15](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.14...v1.0.0-dev.15) (2022-05-25)
+
+
+### Features
+
+* utility functions to get metadata of patch & sigs ([72f16b7](https://github.com/revanced/revanced-patcher/commit/72f16b778587c28d8f8e91da502f197e7dc35d6d))
+
+# [1.0.0-dev.14](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.13...v1.0.0-dev.14) (2022-05-24)
+
+
+### Bug Fixes
+
+* reformat (trigger release) ([45a167e](https://github.com/revanced/revanced-patcher/commit/45a167e7856da0306f796953775c7b7543d9bec0))
+
+# [1.0.0-dev.13](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.12...v1.0.0-dev.13) (2022-05-24)
+
+
+### Performance Improvements
+
+* decode manifest only when not using resource patcher ([40b1fa4](https://github.com/revanced/revanced-patcher/commit/40b1fa43e1704ace29d3e349df2f4a8ea828c5c2))
+
+# [1.0.0-dev.12](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.11...v1.0.0-dev.12) (2022-05-22)
+
+
+### Bug Fixes
+
+* using old instance of `Androlib` when saving ([5630e49](https://github.com/revanced/revanced-patcher/commit/5630e4966310311cdfd53e2ba128255047626adc))
+
+# [1.0.0-dev.11](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.10...v1.0.0-dev.11) (2022-05-22)
+
+
+### Features
+
+* `PatchLoader` ([1a99eca](https://github.com/revanced/revanced-patcher/commit/1a99ecaffe5e55977655316e68b014fdeba374a1))
+* use annotations instead of metadata objects ([6726884](https://github.com/revanced/revanced-patcher/commit/6726884be5af56b6856749e73fb9f4f97559854a))
+
+# [1.0.0-dev.10](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.9...v1.0.0-dev.10) (2022-05-07)
+
+
+### Bug Fixes
+
+* qualifying `Element` with wrong package ([4d74de4](https://github.com/revanced/revanced-patcher/commit/4d74de4061f26c0d7c17fabd849051b429d86033))
+
 # [1.0.0-dev.9](https://github.com/revanced/revanced-patcher/compare/v1.0.0-dev.8...v1.0.0-dev.9) (2022-05-07)
 
 

build.gradle.kts

@@ -1,22 +1,21 @@
 plugins {
-    kotlin("jvm") version "1.6.20"
+    kotlin("jvm") version "1.7.0"
     java
     `maven-publish`
 }
 
 group = "app.revanced"
 
+val githubUsername: String = project.findProperty("gpr.user") as? String ?: System.getenv("GITHUB_ACTOR")
+val githubPassword: String = project.findProperty("gpr.key") as? String ?: System.getenv("GITHUB_TOKEN")
+
 repositories {
     mavenCentral()
     maven {
         url = uri("https://maven.pkg.github.com/revanced/multidexlib2")
         credentials {
-            // DO NOT set these variables in the project's gradle.properties.
+            username = githubUsername
-            // Instead, you should set them in:
+            password = githubPassword
-            // Windows: %homepath%\.gradle\gradle.properties
-            // Linux: ~/.gradle/gradle.properties
-            username = project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR") // DO NOT CHANGE!
-            password = project.findProperty("gpr.key") as String? ?: System.getenv("GITHUB_TOKEN") // DO NOT CHANGE!
         }
     }
 }
@@ -24,12 +23,13 @@ repositories {
 dependencies {
     implementation(kotlin("stdlib"))
 
-    api("org.apktool:apktool-lib:2.6.1")
+    api("xpp3:xpp3:1.1.4c")
+    api("org.apktool:apktool-lib:2.6.2-SNAPSHOT")
     api("app.revanced:multidexlib2:2.5.2.r2")
     api("org.smali:smali:2.5.2")
 
     testImplementation(kotlin("test"))
-}
+    implementation(kotlin("reflect"))}
 
 tasks {
     test {
@@ -45,11 +45,8 @@ java {
     withJavadocJar()
 }
 
-val isGitHubCI = System.getenv("GITHUB_ACTOR") != null
-
 publishing {
     repositories {
-        if (isGitHubCI) {
             maven {
                 name = "GitHubPackages"
                 url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
@@ -58,9 +55,6 @@ publishing {
                     password = System.getenv("GITHUB_TOKEN")
                 }
             }
-        } else {
-            mavenLocal()
-        }
     }
     publications {
         register<MavenPublication>("gpr") {

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.0.0-dev.9
+version = 1.2.2

gradle/wrapper/gradle-wrapper.properties

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

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

@@ -0,0 +1,19 @@
+package app.revanced.patcher
+
+import java.io.File
+
+/**
+ * Options for a 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.
+ */
+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
+)

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

@@ -0,0 +1,13 @@
+package app.revanced.patcher
+
+import app.revanced.patcher.util.dex.DexFile
+
+/**
+ * The result of a patcher.
+ * @param dexFiles The patched dex files.
+ * @param doNotCompress List of relative paths to files to exclude from compressing.
+ */
+data class PatcherResult(
+    val dexFiles: List<DexFile>,
+    val doNotCompress: List<String>? = null
+)

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

@@ -0,0 +1,28 @@
+package app.revanced.patcher.annotation
+
+import app.revanced.patcher.patch.base.Patch
+import app.revanced.patcher.signature.implementation.method.MethodSignature
+
+/**
+ * Annotation to constrain a [Patch] or [MethodSignature] to compatible packages.
+ * @param compatiblePackages A list of packages a [Patch] or [MethodSignature] is compatible with.
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class Compatibility(
+    val compatiblePackages: Array<Package>,
+)
+
+/**
+ * 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 [MethodSignature]is compatible with.
+ */
+@Target()
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class Package(
+    val name: String,
+    val versions: Array<String>
+)

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

@@ -0,0 +1,38 @@
+package app.revanced.patcher.annotation
+
+import app.revanced.patcher.patch.base.Patch
+import app.revanced.patcher.signature.implementation.method.MethodSignature
+
+/**
+ * Annotation to name a [Patch] or [MethodSignature].
+ * @param name A suggestive name for the [Patch] or [MethodSignature].
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class Name(
+    val name: String,
+)
+
+/**
+ * Annotation to describe a [Patch] or [MethodSignature].
+ * @param description A description for the [Patch] or [MethodSignature].
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class Description(
+    val description: String,
+)
+
+
+/**
+ * Annotation to version a [Patch] or [MethodSignature].
+ * @param version The version of a [Patch] or [MethodSignature].
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+@MustBeDocumented
+annotation class Version(
+    val version: String,
+)

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

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

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

@@ -7,12 +7,14 @@ import app.revanced.patcher.patch.base.Patch
 import org.jf.dexlib2.iface.ClassDef
 import java.io.File
 
-internal data class PatcherData(
+data class PatcherData(
-    val internalClasses: MutableList<ClassDef>,
+    internal val internalClasses: MutableList<ClassDef>,
-    val resourceCacheDirectory: String
+    internal val resourceCacheDirectory: String,
+    val packageMetadata: PackageMetadata
 ) {
-    internal val patches = mutableListOf<Patch<Data>>()
 
-    internal val bytecodeData = BytecodeData(patches, internalClasses)
+    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/data/implementation/BytecodeData.kt

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 package app.revanced.patcher.extensions
 
-import app.revanced.patcher.proxy.mutableTypes.MutableMethod.Companion.toMutable
+import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
 import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.builder.BuilderInstruction
 import org.jf.dexlib2.builder.MutableMethodImplementation
@@ -9,6 +9,7 @@ import org.jf.dexlib2.iface.reference.MethodReference
 import org.jf.dexlib2.immutable.ImmutableMethod
 import org.jf.dexlib2.immutable.ImmutableMethodImplementation
 import org.jf.dexlib2.util.MethodUtil
+import java.io.OutputStream
 
 infix fun AccessFlags.or(other: AccessFlags) = this.value or other.value
 infix fun Int.or(other: AccessFlags) = this or other.value
@@ -19,6 +20,19 @@ fun MutableMethodImplementation.addInstructions(index: Int, instructions: List<B
     }
 }
 
+/**
+ * Compare a method to another, considering constructors and parameters.
+ * @param otherMethod The method to compare against.
+ * @return True if the methods match given the conditions.
+ */
+fun Method.softCompareTo(
+    otherMethod: MethodReference
+): Boolean {
+    if (MethodUtil.isConstructor(this) && !parametersEqual(this.parameterTypes, otherMethod.parameterTypes))
+        return false
+    return this.name == otherMethod.name
+}
+
 /**
  * Clones the method.
  * @param registerCount This parameter allows you to change the register count of the method.
@@ -58,14 +72,6 @@ internal fun Method.cloneMutable(
     registerCount: Int = 0,
 ) = clone(registerCount).toMutable()
 
-internal fun Method.softCompareTo(
-    otherMethod: MethodReference
-): Boolean {
-    if (MethodUtil.isConstructor(this) && !parametersEqual(this.parameterTypes, otherMethod.parameterTypes))
-        return false
-    return this.name == otherMethod.name
-}
-
 // FIXME: also check the order of parameters as different order equals different method overload
 internal fun parametersEqual(
     parameters1: Iterable<CharSequence>,
@@ -78,4 +84,9 @@ internal fun parametersEqual(
             )
         }
     }
-}
+}
+
+internal val nullOutputStream: OutputStream =
+    object : OutputStream() {
+        override fun write(b: Int) {}
+    }

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

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

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

@@ -3,20 +3,17 @@ package app.revanced.patcher.patch.base
 import app.revanced.patcher.data.base.Data
 import app.revanced.patcher.patch.implementation.BytecodePatch
 import app.revanced.patcher.patch.implementation.ResourcePatch
-import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
 import app.revanced.patcher.patch.implementation.misc.PatchResult
 
 
 /**
  * A ReVanced patch.
- * Can either be a [ResourcePatch] or a [BytecodePatch]
+ * Can either be a [ResourcePatch] or a [BytecodePatch].
  */
-abstract class Patch<out T : Data>(
+abstract class Patch<out T : Data> {
-    open val metadata: PatchMetadata
+
-) {
     /**
      * The main function of the [Patch] which the patcher will call.
      */
-    abstract fun execute(data: @UnsafeVariance T): PatchResult // FIXME: remove the UnsafeVariance annotation
+    abstract fun execute(data: @UnsafeVariance T): PatchResult
-
 }

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

@@ -2,15 +2,12 @@ package app.revanced.patcher.patch.implementation
 
 import app.revanced.patcher.data.implementation.BytecodeData
 import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
+import app.revanced.patcher.signature.implementation.method.MethodSignature
-import app.revanced.patcher.signature.MethodSignature
 
 /**
  * Bytecode patch for the Patcher.
- * @param metadata [PatchMetadata] for the patch.
  * @param signatures A list of [MethodSignature] this patch relies on.
  */
 abstract class BytecodePatch(
-    override val metadata: PatchMetadata,
     val signatures: Iterable<MethodSignature>
-) : Patch<BytecodeData>(metadata)
+) : Patch<BytecodeData>()

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

@@ -2,12 +2,8 @@ package app.revanced.patcher.patch.implementation
 
 import app.revanced.patcher.data.implementation.ResourceData
 import app.revanced.patcher.patch.base.Patch
-import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
 
 /**
  * Resource patch for the Patcher.
- * @param metadata [PatchMetadata] for the patch.
  */
-abstract class ResourcePatch(
+abstract class ResourcePatch : Patch<ResourceData>()
-    override val metadata: PatchMetadata
-) : Patch<ResourceData>(metadata)

src/main/kotlin/app/revanced/patcher/patch/implementation/metadata/PatchMetadata.kt

@@ -1,29 +0,0 @@
-package app.revanced.patcher.patch.implementation.metadata
-
-import app.revanced.patcher.patch.base.Patch
-
-/**
- * Metadata about a [Patch].
- * @param shortName A suggestive short name for the [Patch].
- * @param name A suggestive name for the [Patch].
- * @param description A description for the [Patch].
- * @param compatiblePackages A list of packages this [Patch] is compatible with.
- * @param version The version of the [Patch].
- */
-data class PatchMetadata(
-    val shortName: String,
-    val name: String,
-    val description: String,
-    val compatiblePackages: Iterable<PackageMetadata>,
-    val version: String,
-)
-
-/**
- * Metadata about a package.
- * @param name The package name.
- * @param versions Compatible versions of the package.
- */
-data class PackageMetadata(
-    val name: String,
-    val versions: Iterable<String>
-)

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

@@ -24,10 +24,12 @@ interface PatchResult {
     }
 }
 
-class PatchResultError(private val errorMessage: String) : PatchResult {
+class PatchResultError(
-    fun errorMessage(): String {
+    errorMessage: String?, cause: Exception?
-        return errorMessage
+) : Exception(errorMessage, cause), PatchResult {
-    }
+    constructor(errorMessage: String) : this(errorMessage, null)
+    constructor(cause: Exception) : this(cause.message, cause)
+
 }
 
 class PatchResultSuccess : PatchResult

src/main/kotlin/app/revanced/patcher/signature/MethodSignature.kt

@@ -1,111 +0,0 @@
-package app.revanced.patcher.signature
-
-import app.revanced.patcher.data.implementation.MethodNotFoundException
-import app.revanced.patcher.patch.implementation.metadata.PackageMetadata
-import org.jf.dexlib2.Opcode
-
-/**
- * Represents the [MethodSignature] for a method.
- * @param metadata Metadata for this [MethodSignature].
- * @param returnType The return type of the method.
- * @param accessFlags The access flags of the method.
- * @param methodParameters 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 `null` opcode is equals to an unknown opcode.
- */
-class MethodSignature(
-    val metadata: MethodSignatureMetadata,
-    internal val returnType: String?,
-    internal val accessFlags: Int?,
-    internal val methodParameters: Iterable<String>?,
-    internal val opcodes: Iterable<Opcode?>?,
-    internal val strings: Iterable<String>? = null
-) {
-    /**
-     * The result of the signature
-     */
-    var result: SignatureResolverResult? = null
-        get() {
-            return field ?: throw MethodNotFoundException(
-                "Could not resolve required signature ${metadata.name}"
-            )
-        }
-    val resolved: Boolean
-        get() {
-            var resolved = false
-            try {
-                resolved = result != null
-            } catch (_: Exception) {
-            }
-            return resolved
-        }
-}
-
-/**
- * Metadata about a [MethodSignature].
- * @param name A suggestive name for the [MethodSignature].
- * @param methodMetadata Metadata about the method for the [MethodSignature].
- * @param patternScanMethod The pattern scanning method the pattern scanner should rely on.
- * Can either be [PatternScanMethod.Fuzzy] or [PatternScanMethod.Direct].
- * @param description An optional description for the [MethodSignature].
- * @param compatiblePackages The list of packages the [MethodSignature] is compatible with.
- * @param version The version of this signature.
- */
-data class MethodSignatureMetadata(
-    val name: String,
-    val methodMetadata: MethodMetadata?,
-    val patternScanMethod: PatternScanMethod,
-    val compatiblePackages: Iterable<PackageMetadata>,
-    val description: String?,
-    val version: String
-)
-
-/**
- * Metadata about the method for a [MethodSignature].
- * @param definingClass The defining class name of the method.
- * @param name A suggestive name for the method which the [MethodSignature] was created for.
- */
-data class MethodMetadata(
-    val definingClass: String?,
-    val name: String?
-)
-
-/**
- * The method, the patcher should rely on when scanning the opcode pattern of a [MethodSignature]
- */
-interface PatternScanMethod {
-    /**
-     * When comparing the signature, if one or more of the opcodes do not match, skip.
-     */
-    class Direct : PatternScanMethod
-
-    /**
-     * When comparing the signature, if [threshold] or more of the opcodes do not match, skip.
-     */
-    class Fuzzy(internal val threshold: Int) : PatternScanMethod {
-        /**
-         * A list of warnings the resolver found.
-         *
-         * This list will be allocated when the signature has been found.
-         * Meaning, if the signature was not found,
-         * or the signature was not yet resolved,
-         * the list will be null.
-         */
-        var warnings: List<Warning>? = null
-
-        /**
-         * Represents a resolver warning.
-         * @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/signature/SignatureResolverResult.kt

@@ -1,48 +0,0 @@
-package app.revanced.patcher.signature
-
-import app.revanced.patcher.extensions.softCompareTo
-import app.revanced.patcher.proxy.ClassProxy
-import app.revanced.patcher.signature.resolver.SignatureResolver
-import org.jf.dexlib2.iface.Method
-
-/**
- * Represents the result of a [SignatureResolver].
- * @param definingClassProxy The [ClassProxy] that the matching method was found in.
- * @param resolvedMethod The actual matching method.
- * @param scanData Opcodes pattern scan result.
- */
-data class SignatureResolverResult(
-    val definingClassProxy: ClassProxy,
-    val scanData: PatternScanResult,
-    private val resolvedMethod: Method,
-) {
-    /**
-     * Returns the **mutable** method by the [resolvedMethod] from the [definingClassProxy].
-     *
-     * Please note, this method allocates a [ClassProxy].
-     * Use [immutableMethod] where possible.
-     */
-    val method
-        get() = definingClassProxy.resolve().methods.first {
-            it.softCompareTo(resolvedMethod)
-        }
-
-    /**
-     * Returns the **immutable** method by the [resolvedMethod] from the [definingClassProxy].
-     *
-     * If you need to modify the method, use [method] instead.
-     */
-    val immutableMethod: Method
-        get() = definingClassProxy.immutableClass.methods.first {
-            it.softCompareTo(resolvedMethod)
-        }
-
-    fun findParentMethod(signature: MethodSignature): SignatureResolverResult? {
-        return SignatureResolver.resolveFromProxy(definingClassProxy, signature)
-    }
-}
-
-data class PatternScanResult(
-    val startIndex: Int,
-    val endIndex: Int
-)

src/main/kotlin/app/revanced/patcher/signature/base/Signature.kt

@@ -0,0 +1,9 @@
+package app.revanced.patcher.signature.base
+
+import app.revanced.patcher.signature.implementation.method.MethodSignature
+
+/**
+ * A ReVanced signature.
+ * Can be a [MethodSignature].
+ */
+interface Signature

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

@@ -0,0 +1,33 @@
+package app.revanced.patcher.signature.implementation.method
+
+import app.revanced.patcher.data.implementation.MethodNotFoundException
+import app.revanced.patcher.extensions.MethodSignatureExtensions.name
+import app.revanced.patcher.signature.base.Signature
+import app.revanced.patcher.signature.implementation.method.resolver.SignatureResolverResult
+import org.jf.dexlib2.Opcode
+
+/**
+ * Represents the [MethodSignature] for a method.
+ * @param returnType The return type of the method.
+ * @param accessFlags The access flags of the method.
+ * @param methodParameters 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 `null` opcode is equals to an unknown opcode.
+ */
+abstract class MethodSignature(
+    internal val returnType: String?,
+    internal val accessFlags: Int?,
+    internal val methodParameters: Iterable<String>?,
+    internal val opcodes: Iterable<Opcode?>?,
+    internal val strings: Iterable<String>? = null
+) : Signature {
+    /**
+     * The result of the signature
+     */
+    var result: SignatureResolverResult? = null
+        @Throws(MethodNotFoundException::class)
+        get() {
+            return field ?: throw MethodNotFoundException("Could not resolve required signature ${this.name}")
+        }
+}

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

@@ -0,0 +1,32 @@
+package app.revanced.patcher.signature.implementation.method.annotation
+
+import app.revanced.patcher.signature.implementation.method.MethodSignature
+
+/**
+ * Annotations for a method which matches to a [MethodSignature].
+ * @param definingClass The defining class name of the method.
+ * @param name A suggestive name for the method which the [MethodSignature] 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 [MethodSignature] 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 [MethodSignature] directly.
+ */
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class DirectPatternScanMethod

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

@@ -1,13 +1,10 @@
-package app.revanced.patcher.signature.resolver
+package app.revanced.patcher.signature.implementation.method.resolver
 
 import app.revanced.patcher.data.PatcherData
 import app.revanced.patcher.data.implementation.proxy
+import app.revanced.patcher.extensions.MethodSignatureExtensions.fuzzyThreshold
 import app.revanced.patcher.extensions.parametersEqual
-import app.revanced.patcher.proxy.ClassProxy
+import app.revanced.patcher.signature.implementation.method.MethodSignature
-import app.revanced.patcher.signature.MethodSignature
-import app.revanced.patcher.signature.PatternScanMethod
-import app.revanced.patcher.signature.PatternScanResult
-import app.revanced.patcher.signature.SignatureResolverResult
 import org.jf.dexlib2.Opcode
 import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.Method
@@ -15,7 +12,7 @@ import org.jf.dexlib2.iface.instruction.Instruction
 import org.jf.dexlib2.iface.instruction.formats.Instruction21c
 import org.jf.dexlib2.iface.reference.StringReference
 
-internal class SignatureResolver(
+internal class MethodSignatureResolver(
     private val classes: List<ClassDef>,
     private val methodSignatures: Iterable<MethodSignature>
 ) {
@@ -39,7 +36,10 @@ internal class SignatureResolver(
 
     // These functions do not require the constructor values, so they can be static.
     companion object {
-        fun resolveFromProxy(classProxy: ClassProxy, signature: MethodSignature): SignatureResolverResult? {
+        fun resolveFromProxy(
+            classProxy: app.revanced.patcher.util.proxy.ClassProxy,
+            signature: MethodSignature
+        ): SignatureResolverResult? {
             for (method in classProxy.immutableClass.methods) {
                 val result = compareSignatureToMethod(signature, method) ?: continue
                 return SignatureResolverResult(
@@ -76,19 +76,17 @@ internal class SignatureResolver(
             signature.strings?.let { strings ->
                 method.implementation ?: return null
 
-                method.implementation!!.instructions.let { instructions ->
+                val stringsList = strings.toMutableList()
-                    val stringsList = strings.toMutableList()
 
-                    for (instruction in instructions) {
+                for (instruction in method.implementation!!.instructions) {
-                        if (instruction.opcode != Opcode.CONST_STRING) continue
+                    if (instruction.opcode != Opcode.CONST_STRING) continue
 
-                        val string = ((instruction as Instruction21c).reference as StringReference).string
+                    val string = ((instruction as Instruction21c).reference as StringReference).string
-                        val i = stringsList.indexOfFirst { it == string }
+                    val i = stringsList.indexOfFirst { it == string }
-                        if (i != -1) stringsList.removeAt(i)
+                    if (i != -1) stringsList.removeAt(i)
-                    }
-
-                    if (stringsList.isNotEmpty()) return null
                 }
+
+                if (stringsList.isNotEmpty()) return null
             }
 
             return if (signature.opcodes == null) {
@@ -107,9 +105,8 @@ internal class SignatureResolver(
             val count = instructions.count()
             val pattern = signature.opcodes!!
             val size = pattern.count()
-            val method = signature.metadata.patternScanMethod
+
-            val threshold = if (method is PatternScanMethod.Fuzzy)
+            val threshold = signature.fuzzyThreshold
-                method.threshold else 0
 
             for (instructionIndex in 0 until count) {
                 var patternIndex = 0
@@ -126,11 +123,9 @@ internal class SignatureResolver(
                     patternIndex-- // fix pattern offset
 
                     val result = PatternScanResult(instructionIndex, instructionIndex + patternIndex)
-                    if (method is PatternScanMethod.Fuzzy) {
+
-                        method.warnings = generateWarnings(
+                    result.warnings = generateWarnings(signature, instructions, result)
-                            signature, instructions, result
+
-                        )
-                    }
                     return result
                 }
             }
@@ -152,7 +147,7 @@ internal class SignatureResolver(
                     correctOpcode != patternOpcode
                 ) {
                     this.add(
-                        PatternScanMethod.Fuzzy.Warning(
+                        PatternScanResult.Warning(
                             correctOpcode, patternOpcode,
                             instructionIndex, patternIndex,
                         )

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

@@ -0,0 +1,75 @@
+package app.revanced.patcher.signature.implementation.method.resolver
+
+import app.revanced.patcher.extensions.softCompareTo
+import app.revanced.patcher.signature.implementation.method.MethodSignature
+import app.revanced.patcher.util.proxy.ClassProxy
+import org.jf.dexlib2.Opcode
+import org.jf.dexlib2.iface.Method
+
+/**
+ * Represents the result of a [MethodSignatureResolver].
+ * @param definingClassProxy The [ClassProxy] that the matching method was found in.
+ * @param resolvedMethod The actual matching method.
+ * @param scanResult Opcodes pattern scan result.
+ */
+data class SignatureResolverResult(
+    val definingClassProxy: ClassProxy,
+    val scanResult: PatternScanResult,
+    private val resolvedMethod: Method,
+) {
+    /**
+     * Returns the **mutable** method by the [resolvedMethod] from the [definingClassProxy].
+     *
+     * Please note, this method allocates a [ClassProxy].
+     * Use [immutableMethod] where possible.
+     */
+    val method
+        get() = definingClassProxy.resolve().methods.first {
+            it.softCompareTo(resolvedMethod)
+        }
+
+    /**
+     * Returns the **immutable** method by the [resolvedMethod] from the [definingClassProxy].
+     *
+     * If you need to modify the method, use [method] instead.
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    val immutableMethod: Method
+        get() = definingClassProxy.immutableClass.methods.first {
+            it.softCompareTo(resolvedMethod)
+        }
+
+    fun findParentMethod(signature: MethodSignature): SignatureResolverResult? {
+        return MethodSignatureResolver.resolveFromProxy(definingClassProxy, signature)
+    }
+}
+
+data class PatternScanResult(
+    val startIndex: Int,
+    val endIndex: Int
+) {
+    /**
+     * A list of warnings the resolver found.
+     *
+     * This list will be allocated when the signature has been found.
+     * Meaning, if the signature was not found,
+     * or the signature was not yet resolved,
+     * the list will be null.
+     */
+    var warnings: List<Warning>? = null
+
+    /**
+     * Represents a resolver warning.
+     * @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/util/ListBackedSet.kt

@@ -1,6 +1,6 @@
 package app.revanced.patcher.util
 
-class ListBackedSet<E>(private val list: MutableList<E>) : MutableSet<E> {
+internal class ListBackedSet<E>(private val list: MutableList<E>) : MutableSet<E> {
     override val size get() = list.size
     override fun add(element: E) = list.add(element)
     override fun addAll(elements: Collection<E>) = list.addAll(elements)