fix: migrate to latest patcher api changes

build.gradle.kts

@@ -24,7 +24,7 @@ repositories {
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib:1.6.21")
-    implementation("app.revanced:revanced-patcher:1.0.0-dev.16")
+    implementation("app.revanced:revanced-patcher:1.0.0-dev.17")
 
     implementation("info.picocli:picocli:4.6.3")
 

src/main/kotlin/app/revanced/cli/MainCommand.kt

@@ -1,7 +1,7 @@
 package app.revanced.cli
 
+import app.revanced.patcher.PatcherOptions
 import app.revanced.patcher.annotation.Name
-import app.revanced.patcher.extensions.findAnnotationRecursively
 import app.revanced.patcher.util.patch.implementation.JarPatchBundle
 import app.revanced.utils.adb.Adb
 import app.revanced.utils.patcher.addPatchesFiltered
@@ -54,21 +54,18 @@ internal object MainCommand : Runnable {
 
     override fun run() {
         if (listOnly) {
-            for (patchBundlePath in patchBundles)
+            for (patchBundlePath in patchBundles) for (it in JarPatchBundle(patchBundlePath).loadPatches()) {
-                for (it in JarPatchBundle(patchBundlePath).loadPatches())
+
+                // TODO: adjust extension methods to be able to do this
+                val name = (it.annotations.find { it is Name } as? Name)?.name ?: it.simpleName
                 println(
-                        "[available] ${
+                    "[available] $name"
-                            it.findAnnotationRecursively(
-                                Name::class.java
-                            )?.name ?: it::class.java.name
-                        }"
                 )
+            }
             return
         }
 
-        val patcher = app.revanced.patcher.Patcher(
+        val patcher = app.revanced.patcher.Patcher(PatcherOptions(inputFile, cacheDirectory, patchResources))
-            inputFile, cacheDirectory, patchResources
-        )
 
         if (signatureCheck) {
             patcher.addPatchesFiltered()

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

@@ -31,7 +31,8 @@ internal class Patcher {
             }
 
             if (MainCommand.patchResources) {
-                for (file in File(MainCommand.cacheDirectory).resolve("build/").listFiles(FileFilter { it.isDirectory })?.first()?.listFiles()!!) {
+                for (file in File(MainCommand.cacheDirectory).resolve("build/").listFiles(FileFilter { it.isDirectory })
+                    ?.first()?.listFiles()!!) {
                     if (!file.isDirectory) {
                         zipFileSystem.replaceFile(file.name, file.readBytes())
                         continue

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

@@ -2,29 +2,23 @@ package app.revanced.utils.patcher
 
 import app.revanced.cli.MainCommand
 import app.revanced.patcher.Patcher
-import app.revanced.patcher.annotation.Compatibility
-import app.revanced.patcher.annotation.Name
 import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.extensions.findAnnotationRecursively
+import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
+import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.patch.base.Patch
 import app.revanced.patcher.util.patch.implementation.JarPatchBundle
 
 fun Patcher.addPatchesFiltered(
-    packageCompatibilityFilter: Boolean = true,
-    packageVersionCompatibilityFilter: Boolean = true,
     includeFilter: Boolean = false
 ) {
     val packageName = this.packageName
     val packageVersion = this.packageVersion
 
     MainCommand.patchBundles.forEach { bundle ->
-        val includedPatches = mutableListOf<Patch<Data>>()
+        val includedPatches = mutableListOf<Class<out Patch<Data>>>()
-        JarPatchBundle(bundle).loadPatches().forEach patch@{ p ->
+        JarPatchBundle(bundle).loadPatches().forEach patch@{ patch ->
-            val patch = p.getDeclaredConstructor().newInstance()
+            val compatiblePackages = patch.compatiblePackages
-
+            val patchName = patch.patchName
-            val compatibilityAnnotation = patch.javaClass.findAnnotationRecursively(Compatibility::class.java)
-
-            val patchName = patch.javaClass.findAnnotationRecursively(Name::class.java)?.name ?: patch.javaClass.name
 
             val prefix = "[skipped] $patchName"
 
@@ -33,26 +27,18 @@ fun Patcher.addPatchesFiltered(
                 return@patch
             }
 
-            if (packageVersionCompatibilityFilter || packageCompatibilityFilter) {
+            if (compatiblePackages == null) println("$prefix: Missing compatibility annotation. Continuing.")
-
+            else compatiblePackages.forEach { compatiblePackage ->
-                if (compatibilityAnnotation == null) {
+                if (compatiblePackage.name != packageName) {
-                    println("$prefix: Missing compatibility annotation.")
-                    return@patch
-                }
-
-
-                compatibilityAnnotation.compatiblePackages.forEach { compatiblePackage ->
-                    if (packageCompatibilityFilter && compatiblePackage.name != packageName) {
                     println("$prefix: Package name not matching ${compatiblePackage.name}.")
                     return@patch
                 }
 
-                    if (packageVersionCompatibilityFilter && !compatiblePackage.versions.any { it == packageVersion }) {
+                if (!compatiblePackage.versions.any { it == packageVersion }) {
                     println("$prefix: Unsupported version.")
                     return@patch
                 }
             }
-            }
 
             includedPatches.add(patch)
             println("[added] $patchName")

src/main/kotlin/app/revanced/utils/signature/Signature.kt

@@ -1,28 +1,24 @@
 package app.revanced.utils.signature
 
 import app.revanced.patcher.Patcher
-import app.revanced.patcher.extensions.findAnnotationRecursively
-import app.revanced.patcher.signature.implementation.method.annotation.FuzzyPatternScanMethod
-import app.revanced.patcher.signature.implementation.method.annotation.MatchingMethod
 import org.jf.dexlib2.iface.Method
 
 object Signature {
 
     fun checkSignatures(patcher: Patcher) {
+        TODO()
+        /**
         val failed = mutableListOf<String>()
         for (signature in patcher.resolveSignatures()) {
         val signatureClass = signature::class.java
-            val signatureName =
+        val signatureName = signature.name ?: signatureClass.simpleName
-                signatureClass.findAnnotationRecursively(app.revanced.patcher.annotation.Name::class.java)?.name
-                    ?: signatureClass.name
         if (!signature.resolved) {
         failed.add(signatureName)
         continue
         }
 
         val method = signature.result!!.method
-            val matchingMethod =
+        val matchingMethod = signature.matchingMethod ?: MatchingMethod()
-                signatureClass.findAnnotationRecursively(MatchingMethod::class.java) ?: MatchingMethod()
 
         println(
         """
@@ -32,7 +28,7 @@ object Signature {
         """.trimIndent()
         )
 
-            signatureClass.findAnnotationRecursively(FuzzyPatternScanMethod::class.java)?.let {
+        signature.fuzzyThreshold.let {
         val warnings = signature.result!!.scanResult.warnings!!
         println(
         """
@@ -50,6 +46,7 @@ object Signature {
         ${failed.joinToString(separator = "\n") { it }}
         """.trimIndent()
         )
+         */
     }
 
     private fun Method.toStr(): String {