chore(release): 1.1.4 [skip ci]

## [1.1.4](https://github.com/revanced/revanced-cli/compare/v1.1.3...v1.1.4) (2022-05-26)

### Bug Fixes

* migrate from `PatchLoader.load(...)` to `JarPatchBundle(...).loadPatches()` ([cabd32f](cabd32fda4))

.idea/vcs.xml

@@ -8,5 +8,7 @@
   </component>
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/../revanced-patcher" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/../revanced-patches" vcs="Git" />
   </component>
 </project>

CHANGELOG.md

@@ -1,3 +1,33 @@
+## [1.1.4](https://github.com/revanced/revanced-cli/compare/v1.1.3...v1.1.4) (2022-05-26)
+
+
+### Bug Fixes
+
+* migrate from `PatchLoader.load(...)` to `JarPatchBundle(...).loadPatches()` ([cabd32f](https://github.com/revanced/revanced-cli/commit/cabd32fda41d32616a61ae450c60e1ee7c35bc59))
+
+## [1.1.3](https://github.com/revanced/revanced-cli/compare/v1.1.2...v1.1.3) (2022-05-25)
+
+
+### Bug Fixes
+
+* only accept directories when looking for files in resource patch ([c76da7e](https://github.com/revanced/revanced-cli/commit/c76da7e5ffa208860eea008dad358e4e3bb3d735))
+
+## [1.1.2](https://github.com/revanced/revanced-cli/compare/v1.1.1...v1.1.2) (2022-05-22)
+
+
+### Bug Fixes
+
+* delete `outputFile` after deploying ([329f8a3](https://github.com/revanced/revanced-cli/commit/329f8a383fe52f4c2a66075d893c6599d3550bee))
+
+## [1.1.1](https://github.com/revanced/revanced-cli/compare/v1.1.0...v1.1.1) (2022-05-22)
+
+
+### Bug Fixes
+
+* breaking changes by `revanced-patcher` dependency ([51d2504](https://github.com/revanced/revanced-cli/commit/51d250491f390695aedc64e7ee71a9dcf99d695c))
+* wrong use of dependency to `revanced-patches` ([351de6c](https://github.com/revanced/revanced-cli/commit/351de6cb90aa0f2ec93e8b8f6c10d7d312082079))
+* wrong use of variable substitution / typo ([81d53b5](https://github.com/revanced/revanced-cli/commit/81d53b5518454e479b7a8f2e9be934bee30702af)), closes [revanced/revanced-cli#12](https://github.com/revanced/revanced-cli/issues/12)
+
 # [1.1.0-dev.3](https://github.com/revanced/revanced-cli/compare/v1.1.0-dev.2...v1.1.0-dev.3) (2022-05-15)
 
 

build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    kotlin("jvm") version "1.6.20"
+    kotlin("jvm") version "1.6.21"
     id("com.github.johnrengelman.shadow") version "7.1.2"
     java
     `maven-publish`
@@ -23,13 +23,15 @@ repositories {
 }
 
 dependencies {
-    implementation(kotlin("stdlib"))
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.6.21")
-    implementation("app.revanced:revanced-patcher:+")
+    implementation("app.revanced:revanced-patcher:1.0.0-dev.16")
-    implementation("info.picocli:picocli:+")
+    implementation("app.revanced:revanced-patches:1.0.0-dev.11")
+
+    implementation("info.picocli:picocli:4.6.3")
 
-    implementation("me.tongfei:progressbar:+")
     implementation("com.github.li-wjohnson:jadb:master-SNAPSHOT") // using a fork instead.
-    implementation("org.bouncycastle:bcpkix-jdk15on:+")
+    implementation("org.bouncycastle:bcpkix-jdk15on:1.70")
+    implementation("org.jetbrains.kotlin:kotlin-reflect:1.6.21")
 }
 
 java {

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.1.0-dev.3
+version = 1.1.4

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-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/cli/MainCommand.kt

@@ -1,7 +1,11 @@
 package app.revanced.cli
 
-import app.revanced.patch.Patches
+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
+import app.revanced.utils.signature.Signature
 import picocli.CommandLine.*
 import java.io.File
 
@@ -16,7 +20,7 @@ internal object MainCommand : Runnable {
     internal var includedPatches = arrayOf<String>()
 
     @Option(names = ["-p", "--patches"], description = ["One or more bundles of patches"])
-    internal var patchBundles = arrayOf<File>()
+    internal var patchBundles = arrayOf<String>()
 
     @Option(names = ["-t", "--temp-dir"], description = ["Temporal resource cache directory"], required = true)
     internal lateinit var cacheDirectory: String
@@ -33,6 +37,9 @@ internal object MainCommand : Runnable {
     @Option(names = ["-l", "--list"], description = ["List patches only"])
     internal var listOnly: Boolean = false
 
+    @Option(names = ["-s", "--signature-checker"], description = ["Check signatures of all patches"])
+    internal var signatureCheck: Boolean = false
+
     @Option(names = ["-m", "--merge"], description = ["One or more dex file containers to merge"])
     internal var mergeFiles = listOf<File>()
 
@@ -47,36 +54,43 @@ internal object MainCommand : Runnable {
 
     override fun run() {
         if (listOnly) {
-            patchBundles.forEach {
+            for (patchBundlePath in patchBundles)
-                Patches.load(it).forEach {
+                for (it in JarPatchBundle(patchBundlePath).loadPatches())
-                    println(it().metadata)
+                    println(
-                }
+                        "[available] ${
-            }
+                            it.javaClass.findAnnotationRecursively(
+                                Name::class.java
+                            )?.name ?: Name::class.java.name
+                        }"
+                    )
             return
         }
 
         val patcher = app.revanced.patcher.Patcher(
-            inputFile,
+            inputFile, cacheDirectory, patchResources
-            cacheDirectory,
-            patchResources
         )
 
-        Patcher.start(patcher)
+        if (signatureCheck) {
-
+            patcher.addPatchesFiltered()
-        if (clean) {
+            Signature.checkSignatures(patcher)
-            File(cacheDirectory).deleteRecursively()
+            return
         }
 
         val outputFile = File(outputPath)
 
+        var adb: Adb? = null
         deploy?.let {
-            Adb(
+            adb = Adb(
-                outputFile,
+                outputFile, patcher.packageName, deploy!!
-                patcher.packageName,
+            )
-                deploy!!
-            ).deploy()
         }
 
+        Patcher.start(patcher)
+
+        if (clean) File(cacheDirectory).deleteRecursively()
+
+        adb?.deploy()
+
         if (clean) outputFile.delete()
     }
 }

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

@@ -1,25 +1,22 @@
 package app.revanced.cli
 
-import app.revanced.patch.Patches
-import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
 import app.revanced.utils.filesystem.FileSystemUtils
+import app.revanced.utils.patcher.addPatchesFiltered
+import app.revanced.utils.patcher.applyPatchesPrint
+import app.revanced.utils.patcher.mergeFiles
 import app.revanced.utils.signing.Signer
 import java.io.File
+import java.io.FileFilter
 
 internal class Patcher {
     internal companion object {
         internal fun start(patcher: app.revanced.patcher.Patcher) {
             // merge files like necessary integrations
-            patcher.addFiles(MainCommand.mergeFiles)
+            patcher.mergeFiles()
             // add patches, but filter incompatible or excluded patches
-            patcher.addPatchesFiltered()
+            patcher.addPatchesFiltered(includeFilter = MainCommand.includedPatches.isNotEmpty())
             // apply patches
-            for ((meta, result) in patcher.applyPatches {
+            patcher.applyPatchesPrint()
-                println("Applying $it.")
-            }) {
-                println("Applied ${meta.name}. The result was $result.")
-            }
 
             // write output file
             val outFile = File(MainCommand.outputPath)
@@ -34,7 +31,7 @@ internal class Patcher {
             }
 
             if (MainCommand.patchResources) {
-                for (file in File(MainCommand.cacheDirectory).resolve("build/").listFiles().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
@@ -48,40 +45,10 @@ internal class Patcher {
 
             // and sign the apk file
             Signer.signApk(outFile)
+
+            println("[done]")
         }
 
-        private fun app.revanced.patcher.Patcher.addPatchesFiltered() {
-            val packageName = this.packageName
-            val packageVersion = this.packageVersion
-
-            val checkInclude = MainCommand.includedPatches.isNotEmpty()
-
-            MainCommand.patchBundles.forEach { bundle ->
-                val includedPatches = mutableListOf<Patch<Data>>()
-                Patches.load(bundle).forEach patch@{
-                    val patch = it()
-
-                    val filterOutPatches = true
-                    if (filterOutPatches && !patch.metadata.compatiblePackages.any { packageMetadata ->
-                            packageMetadata.name == packageName && packageMetadata.versions.any {
-                                it == packageVersion
-                            }
-                        }) {
-
-                        println("Skipping ${patch.metadata.name} due to incompatibility with current package $packageName.")
-                        return@patch
-                    }
-
-                    if (checkInclude && !MainCommand.includedPatches.contains(patch.metadata.shortName)) {
-                        return@patch
-                    }
-
-                    println("Adding ${patch.metadata.name}.")
-                    includedPatches.add(patch)
 
     }
-                this.addPatches(includedPatches)
-            }
-        }
-    }
 }

src/main/kotlin/app/revanced/patch/Patches.kt

@@ -1,26 +0,0 @@
-package app.revanced.patch
-
-import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
-import java.io.File
-import java.net.URLClassLoader
-
-internal object Patches {
-
-    /**
-     * This method loads patches from a given patch file
-     * @return the loaded patches represented as a list of functions returning instances of [Patch]
-     */
-    internal fun load(patchesJar: File): List<() -> Patch<Data>> {
-        val url = patchesJar.toURI().toURL()
-        val classLoader = URLClassLoader(arrayOf(url))
-
-        val indexClass = classLoader.loadClass("app.revanced.patches.Index")
-
-        val index = indexClass.declaredFields.last()
-        index.isAccessible = true
-
-        @Suppress("UNCHECKED_CAST")
-        return index.get(null) as List<() -> Patch<Data>>
-    }
-}

src/main/kotlin/app/revanced/utils/adb/Constants.kt

@@ -8,7 +8,7 @@ internal object Constants {
     private const val COMMAND_CHMOD_MOUNT = "chmod +x"
     internal const val COMMAND_PID_OF = "pidof -s"
     internal const val COMMAND_CREATE_DIR = "mkdir -p"
-    internal const val COMMAND_LOGCAT = "logcat -c && logcat --pid=$($COMMAND_PID_OF $PLACEHOLDER)"
+    internal const val COMMAND_LOGCAT = "logcat -c && logcat | grep AndroidRuntime"
     internal const val COMMAND_RESTART = "monkey -p $PLACEHOLDER 1 && kill ${'$'}($COMMAND_PID_OF $PLACEHOLDER)"
 
     // default mount file name

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

@@ -0,0 +1,76 @@
+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.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>>()
+        JarPatchBundle(bundle).loadPatches().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
+                }
+
+
+                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 }) return@patch
+                    println("$prefix: Unsupported version.")
+                    return@patch
+                }
+            }
+
+            includedPatches.add(patch)
+            println("[added] $patchName")
+        }
+        this.addPatches(includedPatches)
+    }
+}
+
+fun Patcher.applyPatchesPrint() {
+    this.applyPatches().forEach { (patch, result) ->
+        if (result.isSuccess) {
+            println("[success] $patch")
+            return@forEach
+        }
+        println("[error] $patch:")
+        result.exceptionOrNull()!!.printStackTrace()
+    }
+}
+
+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}"
+    }
+}