add: signature checker and compatibility filters

Signed-off-by: oSumAtrIX <johan.melkonyan1@web.de>

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

@@ -0,0 +1,71 @@
+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.patch.base.Patch
+import app.revanced.patcher.util.patch.PatchLoader
+
+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>>()
+        PatchLoader.loadFromFile(bundle).forEach patch@{ p ->
+            val patch = p.getDeclaredConstructor().newInstance()
+
+            val compatibilityAnnotation = patch.javaClass.findAnnotationRecursively(Compatibility::class.java)
+
+            val patchName = patch.javaClass.findAnnotationRecursively(Name::class.java)?.name ?: Name::class.java.name
+
+            val prefix = "[skipped] $patchName"
+
+            if (includeFilter && !MainCommand.includedPatches.contains(patchName)) {
+                println(prefix)
+                return@patch
+            }
+
+            if (packageVersionCompatibilityFilter || packageCompatibilityFilter) {
+
+                if (compatibilityAnnotation == null) {
+                    println("$prefix: Missing compatibility annotation.")
+                    return@patch
+                }
+
+
+                for (compatiblePackage in compatibilityAnnotation.compatiblePackages) {
+                    if (packageCompatibilityFilter && compatiblePackage.name != packageName) {
+                        println("$prefix: Package name not matching ${compatiblePackage.name}.")
+                        return@patch
+                    }
+
+                    if (!packageVersionCompatibilityFilter || compatiblePackage.versions.any { it == packageVersion }) continue
+                    println("$prefix: Unsupported version.")
+                    return@patch
+                }
+            }
+
+            includedPatches.add(patch)
+            println("[added] $patchName")
+        }
+        this.addPatches(includedPatches)
+    }
+}
+
+fun Patcher.applyPatchesPrint() {
+    for ((patch, result) in this.applyPatches()) {
+        println("[${if (result.isFailure) "error" else "success"}] $patch")
+    }
+}
+
+fun Patcher.mergeFiles() {
+    this.addFiles(MainCommand.mergeFiles)
+}

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

@@ -0,0 +1,58 @@
+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) {
+        val failed = mutableListOf<String>()
+        for (signature in patcher.resolveSignatures()) {
+            val signatureClass = signature::class.java
+            val signatureName =
+                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 =
+                signatureClass.findAnnotationRecursively(MatchingMethod::class.java) ?: MatchingMethod()
+
+            println(
+                """
+                    [Signature] $signatureName
+                    [Method] ${matchingMethod.definingClass}->${matchingMethod.name}
+                    [Match] ${method.definingClass}->${method.toStr()}
+                """.trimIndent()
+            )
+
+            signatureClass.findAnnotationRecursively(FuzzyPatternScanMethod::class.java)?.let {
+                val warnings = signature.result!!.scanResult.warnings!!
+                println(
+                    """
+                        [Warnings: ${warnings.count()}]
+                        ${warnings.joinToString(separator = "\n") { warning -> "${warning.instructionIndex} / ${warning.patternIndex}: ${warning.wrongOpcode} (expected: ${warning.correctOpcode})" }}
+                    """.trimIndent()
+                )
+            }
+        }
+
+        println(
+            """
+                ${"=".repeat(50)}
+                [Failed signatures: ${failed.size}]
+                ${failed.joinToString(separator = "\n") { it }}
+        """.trimIndent()
+        )
+    }
+
+    private fun Method.toStr(): String {
+        return "${this.name}(${this.parameterTypes.joinToString("")})${this.returnType}"
+    }
+}