chore(release): 18.0.0 [skip ci]

# [18.0.0](https://github.com/ReVanced/revanced-patcher/compare/v17.0.0...v18.0.0) (2023-10-22)

### Bug Fixes

* Do not set patch fields if they are empty ([a76ac04](a76ac04214))
* Only allow setting `MethodFingerprint#result` privately ([aed1eac](aed1eac315))

### Code Refactoring

* Change `PatchOption` from abstract to open class ([09cd6aa](09cd6aa568))
* Change data classes to actual classes ([6192089](6192089b71))
* Convert extension functions to member functions ([e2ca507](e2ca50729d))
* Move files to simplify package structure ([124a2e9](124a2e9d3e))
* Remove deprecated classes and members ([a4212f6](a4212f6bf9))

* refactor!: Remove `Fingerprint` interface ([54a2f8f](54a2f8f16f))

### Features

* Add function to reset options to their default value ([ebbaafb](ebbaafb78e))
* Add function to reset options to their default value ([e6de90d](e6de90d300))
* Add getter for default option value ([c7922e9](c7922e90d0))
* Make `PatchOption#values` nullable ([56ce9ec](56ce9ec2f9))
* Name patch option value validator property correctly ([caa634f](caa634fac6))
* Remove patch annotation processor ([4456031](4456031459))
* Use a map for `PatchOption#values` ([54ac139](54ac1394a9))

### Performance Improvements

* Run the garbage collector after writing dex files ([d9fb241](d9fb241d57))

### BREAKING CHANGES

* The `MethodFingerprint#result` member can now only be set inside `MethodFingerprint`.
* The `Fingerprint` interface is no longer present.
* Some extension functions are now member functions.
* This gets rid of data class members.
* Some deprecated classes and members are not present anymore.
* Classes and members have changed packages.
* This gets rid of the existing basic implementations of the `PatchOptions` type and moves extension functions.
* This changes the getter name of the property.
* Various patch constructor signatures have changed.

.github/workflows/pull_request.yml

@@ -1,4 +1,4 @@
-name: PR to main
+name: Open a PR to main
 
 on:
   push:
@@ -7,7 +7,7 @@ on:
   workflow_dispatch:
 
 env:
-  MESSAGE: merge branch `${{ github.head_ref || github.ref_name }}` to `main`
+  MESSAGE: Merge branch `${{ github.head_ref || github.ref_name }}` to `main`
 
 jobs:
   pull-request:
@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Open pull request
         uses: repo-sync/pull-request@v2
         with:

.github/workflows/release.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           # Make sure the release step uses its own credentials:
           # https://github.com/cycjimmy/semantic-release-action#private-packages

build.gradle.kts

@@ -1,4 +1,86 @@
 plugins {
-    kotlin("jvm") version "1.9.0" apply false
+    kotlin("jvm") version "1.9.10"
     alias(libs.plugins.binary.compatibility.validator)
+    `maven-publish`
+    signing
+    java
 }
+
+group = "app.revanced"
+
+tasks {
+    processResources {
+        expand("projectVersion" to project.version)
+    }
+
+    test {
+        useJUnitPlatform()
+        testLogging {
+            events("PASSED", "SKIPPED", "FAILED")
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+    maven { url = uri("https://jitpack.io") }
+    google()
+}
+
+dependencies {
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.xpp3)
+    implementation(libs.smali)
+    implementation(libs.multidexlib2)
+    implementation(libs.apktool.lib)
+    implementation(libs.kotlin.reflect)
+
+    compileOnly(libs.android)
+
+    testImplementation(libs.kotlin.test)
+}
+
+java {
+    withJavadocJar()
+    withSourcesJar()
+}
+
+kotlin {
+    jvmToolchain(11)
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("revanced-patcher-publication") {
+            from(components["java"])
+
+            version = project.version.toString()
+
+            pom {
+                name = "ReVanced Patcher"
+                description = "Patcher used by ReVanced."
+                url = "https://revanced.app"
+
+                licenses {
+                    license {
+                        name = "GNU General Public License v3.0"
+                        url = "https://www.gnu.org/licenses/gpl-3.0.en.html"
+                    }
+                }
+                developers {
+                    developer {
+                        id = "ReVanced"
+                        name = "ReVanced"
+                        email = "contact@revanced.app"
+                    }
+                }
+                scm {
+                    connection = "scm:git:git://github.com/revanced/revanced-patcher.git"
+                    developerConnection = "scm:git:git@github.com:revanced/revanced-patcher.git"
+                    url = "https://github.com/revanced/revanced-patcher"
+                }
+            }
+        }
+    }
+}

gradle.properties

@@ -1,4 +1,4 @@
 org.gradle.parallel = true
 org.gradle.caching = true
 kotlin.code.style = official
-version = 15.0.0-dev.1
+version = 18.0.0

gradle/libs.versions.toml

@@ -1,31 +1,23 @@
 [versions]
 android = "4.1.1.4"
 kotlin-reflect = "1.9.0"
-apktool-lib = "2.8.2-6"
+apktool-lib = "2.9.1"
 kotlin-test = "1.8.20-RC"
-kotlinx-coroutines-core = "1.7.1"
-multidexlib2 = "3.0.3.r2"
+kotlinx-coroutines-core = "1.7.3"
+multidexlib2 = "3.0.3.r3"
 smali = "3.0.3"
-symbol-processing-api = "1.9.0-1.0.11"
 xpp3 = "1.1.4c"
 binary-compatibility-validator = "0.13.2"
-kotlin-compile-testing-ksp = "1.5.0"
-kotlinpoet-ksp = "1.14.2"
-ksp = "1.9.0-1.0.11"
 
 [libraries]
 android = { module = "com.google.android:android", version.ref = "android" }
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin-reflect" }
-apktool-lib = { module = "app.revanced:apktool-lib", version.ref = "apktool-lib" }
+apktool-lib = { module = "app.revanced:apktool", version.ref = "apktool-lib" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin-test" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines-core" }
 multidexlib2 = { module = "app.revanced:multidexlib2", version.ref = "multidexlib2" }
 smali = { module = "com.android.tools.smali:smali", version.ref = "smali" }
-symbol-processing-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "symbol-processing-api" }
 xpp3 = { module = "xpp3:xpp3", version.ref = "xpp3" }
-kotlin-compile-testing = { module = "com.github.tschuchortdev:kotlin-compile-testing-ksp", version.ref = "kotlin-compile-testing-ksp" }
-kotlinpoet-ksp = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlinpoet-ksp" }
 
 [plugins]
 binary-compatibility-validator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binary-compatibility-validator" }
-ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

revanced-patch-annotations-processor/api/revanced-patch-annotations-processor.api

@@ -1,25 +0,0 @@
-public abstract interface annotation class app/revanced/patcher/patch/annotations/CompatiblePackage : java/lang/annotation/Annotation {
-	public abstract fun name ()Ljava/lang/String;
-	public abstract fun versions ()[Ljava/lang/String;
-}
-
-public abstract interface annotation class app/revanced/patcher/patch/annotations/Patch : java/lang/annotation/Annotation {
-	public abstract fun compatiblePackages ()[Lapp/revanced/patcher/patch/annotations/CompatiblePackage;
-	public abstract fun dependencies ()[Ljava/lang/Class;
-	public abstract fun description ()Ljava/lang/String;
-	public abstract fun name ()Ljava/lang/String;
-	public abstract fun requiresIntegrations ()Z
-	public abstract fun use ()Z
-}
-
-public final class app/revanced/patcher/patch/annotations/processor/PatchProcessor : com/google/devtools/ksp/processing/SymbolProcessor {
-	public fun <init> (Lcom/google/devtools/ksp/processing/CodeGenerator;Lcom/google/devtools/ksp/processing/KSPLogger;)V
-	public fun process (Lcom/google/devtools/ksp/processing/Resolver;)Ljava/util/List;
-}
-
-public final class app/revanced/patcher/patch/annotations/processor/PatchProcessorProvider : com/google/devtools/ksp/processing/SymbolProcessorProvider {
-	public fun <init> ()V
-	public fun create (Lcom/google/devtools/ksp/processing/SymbolProcessorEnvironment;)Lapp/revanced/patcher/patch/annotations/processor/PatchProcessor;
-	public synthetic fun create (Lcom/google/devtools/ksp/processing/SymbolProcessorEnvironment;)Lcom/google/devtools/ksp/processing/SymbolProcessor;
-}
-

revanced-patch-annotations-processor/build.gradle.kts

@@ -1,50 +0,0 @@
-plugins {
-    kotlin("jvm") version "1.9.0"
-    `maven-publish`
-    alias(libs.plugins.ksp)
-}
-
-group = "app.revanced"
-
-dependencies {
-    implementation(libs.symbol.processing.api)
-    implementation(libs.kotlinpoet.ksp)
-    implementation(project(":revanced-patcher"))
-
-    testImplementation(libs.kotlin.test)
-    testImplementation(libs.kotlin.compile.testing)
-}
-
-tasks {
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
-    }
-}
-
-kotlin { jvmToolchain(11) }
-
-java {
-    withSourcesJar()
-}
-
-publishing {
-    repositories {
-        mavenLocal()
-        maven {
-            name = "GitHubPackages"
-            url = uri("https://maven.pkg.github.com/revanced/revanced-patch-annotations-processor")
-            credentials {
-                username = System.getenv("GITHUB_ACTOR")
-                password = System.getenv("GITHUB_TOKEN")
-            }
-        }
-    }
-    publications {
-        create<MavenPublication>("gpr") {
-            from(components["java"])
-        }
-    }
-}

revanced-patch-annotations-processor/settings.gradle.kts

@@ -1,2 +0,0 @@
-rootProject.name = "revanced-patch-annotations-processor"
-

revanced-patch-annotations-processor/src/main/kotlin/app/revanced/patcher/patch/annotations/processor/PatchProcessor.kt

@@ -1,198 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.PatchOptions
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotations.Patch
-import com.google.devtools.ksp.processing.*
-import com.google.devtools.ksp.symbol.KSAnnotated
-import com.google.devtools.ksp.symbol.KSAnnotation
-import com.google.devtools.ksp.symbol.KSClassDeclaration
-import com.google.devtools.ksp.symbol.KSType
-import com.google.devtools.ksp.validate
-import com.squareup.kotlinpoet.*
-import com.squareup.kotlinpoet.ksp.toClassName
-import com.squareup.kotlinpoet.ksp.writeTo
-import kotlin.reflect.KClass
-
-class PatchProcessor(
-    private val codeGenerator: CodeGenerator,
-    private val logger: KSPLogger
-) : SymbolProcessor {
-
-    private fun KSAnnotated.isSubclassOf(cls: KClass<*>): Boolean {
-        if (this !is KSClassDeclaration) return false
-
-        if (qualifiedName?.asString() == cls.qualifiedName) return true
-
-        return superTypes.any { it.resolve().declaration.isSubclassOf(cls) }
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    override fun process(resolver: Resolver): List<KSAnnotated> {
-        val executablePatches = buildMap {
-            resolver.getSymbolsWithAnnotation(Patch::class.qualifiedName!!).filter {
-                // Do not check here if Patch is super of the class, because it is expensive.
-                // Check it later when processing.
-                it.validate() && it.isSubclassOf(app.revanced.patcher.patch.Patch::class)
-            }.map {
-                it as KSClassDeclaration
-            }.forEach { patchDeclaration ->
-                patchDeclaration.annotations.find {
-                    it.annotationType.resolve().declaration.qualifiedName!!.asString() == Patch::class.qualifiedName!!
-                }?.let { annotation ->
-                    fun KSAnnotation.property(name: String) =
-                        arguments.find { it.name!!.asString() == name }?.value!!
-
-                    val name =
-                        annotation.property("name").toString().ifEmpty { null }
-
-                    val description =
-                        annotation.property("description").toString().ifEmpty { null }
-
-                    val dependencies =
-                        (annotation.property("dependencies") as List<KSType>).ifEmpty { null }
-
-                    val compatiblePackages =
-                        (annotation.property("compatiblePackages") as List<KSAnnotation>).ifEmpty { null }
-
-                    val use =
-                        annotation.property("use") as Boolean
-
-                    val requiresIntegrations =
-                        annotation.property("requiresIntegrations") as Boolean
-
-                    // Data class for KotlinPoet
-                    data class PatchData(
-                        val name: String?,
-                        val description: String?,
-                        val dependencies: List<ClassName>?,
-                        val compatiblePackages: List<CodeBlock>?,
-                        val use: Boolean,
-                        val requiresIntegrations: Boolean
-                    )
-
-                    this[patchDeclaration] = PatchData(
-                        name,
-                        description,
-                        dependencies?.map { dependency -> dependency.toClassName() },
-                        compatiblePackages?.map {
-                            val packageName = it.property("name")
-                            val packageVersions = (it.property("versions") as List<String>)
-                                .joinToString(", ") { version -> "\"$version\"" }
-
-                            CodeBlock.of(
-                                "%T(%S, setOf(%L))",
-                                app.revanced.patcher.patch.Patch.CompatiblePackage::class,
-                                packageName,
-                                packageVersions
-                            )
-                        },
-                        use,
-                        requiresIntegrations
-                    )
-                }
-            }
-        }
-
-        // If a patch depends on another, that is annotated, the dependency should be replaced with the generated patch,
-        // because the generated patch has all the necessary properties to invoke the super constructor,
-        // unlike the annotated patch.
-        val dependencyResolutionMap = buildMap {
-            executablePatches.values.filter { it.dependencies != null }.flatMap {
-                it.dependencies!!
-            }.distinct().forEach { dependency ->
-                executablePatches.keys.find { it.qualifiedName?.asString() == dependency.toString() }
-                    ?.let { patch ->
-                        this[dependency] = ClassName(
-                            patch.packageName.asString(),
-                            patch.simpleName.asString() + "Generated"
-                        )
-                    }
-            }
-        }
-
-        // kotlin poet generate a class for each patch
-        executablePatches.forEach { (patchDeclaration, patchAnnotation) ->
-            val isBytecodePatch = patchDeclaration.isSubclassOf(BytecodePatch::class)
-
-            val superClass = if (isBytecodePatch) {
-                BytecodePatch::class
-            } else {
-                ResourcePatch::class
-            }
-
-            val contextClass = if (isBytecodePatch) {
-                BytecodeContext::class
-            } else {
-                ResourceContext::class
-            }
-
-            val generatedPatchClassName = ClassName(
-                patchDeclaration.packageName.asString(),
-                patchDeclaration.simpleName.asString() + "Generated"
-            )
-
-            FileSpec.builder(generatedPatchClassName)
-                .addType(
-                    TypeSpec.objectBuilder(generatedPatchClassName)
-                        .superclass(superClass).apply {
-                            patchAnnotation.name?.let { name ->
-                                addSuperclassConstructorParameter("name = %S", name)
-                            }
-
-                            patchAnnotation.description?.let { description ->
-                                addSuperclassConstructorParameter("description = %S", description)
-                            }
-
-                            patchAnnotation.compatiblePackages?.let { compatiblePackages ->
-                                addSuperclassConstructorParameter(
-                                    "compatiblePackages = setOf(%L)",
-                                    compatiblePackages.joinToString(", ")
-                                )
-                            }
-
-                            patchAnnotation.dependencies?.let { dependencies ->
-                                addSuperclassConstructorParameter(
-                                    "dependencies = setOf(%L)",
-                                    buildList {
-                                        addAll(dependencies)
-                                        // Also add the source class of the generated class so that it is also executed
-                                        add(patchDeclaration.toClassName())
-                                    }.joinToString(", ") { dependency ->
-                                        "${(dependencyResolutionMap[dependency] ?: dependency)}::class"
-                                    }
-                                )
-                            }
-                            addSuperclassConstructorParameter(
-                                "use = %L", patchAnnotation.use
-                            )
-
-                            addSuperclassConstructorParameter(
-                                "requiresIntegrations = %L",
-                                patchAnnotation.requiresIntegrations
-                            )
-                        }
-                        .addFunction(
-                            FunSpec.builder("execute")
-                                .addModifiers(KModifier.OVERRIDE)
-                                .addParameter("context", contextClass)
-                                .build()
-                        )
-                        .addProperty(
-                            PropertySpec.builder("options", PatchOptions::class, KModifier.OVERRIDE)
-                                .initializer("%T.options", patchDeclaration.toClassName())
-                                .build()
-                        )
-                        .build()
-                ).build().writeTo(
-                    codeGenerator,
-                    Dependencies(false, patchDeclaration.containingFile!!)
-                )
-        }
-
-        return emptyList()
-    }
-}

revanced-patch-annotations-processor/src/main/kotlin/app/revanced/patcher/patch/annotations/processor/PatchProcessorProvider.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor
-
-import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
-import com.google.devtools.ksp.processing.SymbolProcessorProvider
-
-class PatchProcessorProvider : SymbolProcessorProvider {
-    override fun create(environment: SymbolProcessorEnvironment) =
-        PatchProcessor(environment.codeGenerator, environment.logger)
-}

revanced-patch-annotations-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider

@@ -1 +0,0 @@
-app.revanced.patcher.patch.annotations.processor.PatchProcessorProvider

revanced-patch-annotations-processor/src/test/kotlin/app/revanced/patcher/patch/annotations/processor/TestPatchAnnotationProcessor.kt

@@ -1,131 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor
-
-import app.revanced.patcher.patch.Patch
-import com.tschuchort.compiletesting.KotlinCompilation
-import com.tschuchort.compiletesting.SourceFile
-import com.tschuchort.compiletesting.kspWithCompilation
-import com.tschuchort.compiletesting.symbolProcessorProviders
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertNull
-
-class TestPatchAnnotationProcessor {
-    // region Processing
-
-    @Test
-    fun testProcessing() = assertEquals(
-        "Processable patch", compile(
-            getSourceFile(
-                "processing", "ProcessablePatch"
-            )
-        ).loadPatch("$SAMPLE_PACKAGE.processing.ProcessablePatchGenerated").name
-    )
-
-    // endregion
-
-    // region Dependencies
-
-    @Test
-    fun testDependencies() {
-        compile(
-            getSourceFile(
-                "dependencies", "DependentPatch"
-            ), getSourceFile(
-                "dependencies", "DependencyPatch"
-            )
-        ).let { result ->
-            result.loadPatch("$SAMPLE_PACKAGE.dependencies.DependentPatchGenerated").let {
-                // Dependency as well as the source class of the generated class.
-                assertEquals(
-                    2,
-                    it.dependencies!!.size
-                )
-
-                // The last dependency is always the source class of the generated class to respect
-                // order of dependencies.
-                assertEquals(
-                    result.loadPatch("$SAMPLE_PACKAGE.dependencies.DependentPatch")::class,
-                    it.dependencies!!.last()
-                )
-            }
-        }
-    }
-
-    // endregion
-
-    // region Options
-
-    @Test
-    fun testOptions() {
-        val patch = compile(
-            getSourceFile(
-                "options", "OptionsPatch"
-            )
-        ).loadPatch("$SAMPLE_PACKAGE.options.OptionsPatchGenerated")
-
-        assertNotNull(patch.options)
-        assertEquals(patch.options["print"].title, "Print message")
-    }
-
-    // endregion
-
-    // region Limitations
-    @Test
-    fun failingManualDependency() = assertNull(
-        compile(
-            getSourceFile(
-                "limitations/manualdependency", "DependentPatch"
-            ), getSourceFile(
-                "limitations/manualdependency", "DependencyPatch"
-            )
-        ).loadPatch("$SAMPLE_PACKAGE.limitations.manualdependency.DependentPatchGenerated").dependencies
-    )
-
-    // endregion
-
-    private companion object Utils {
-        const val SAMPLE_PACKAGE = "app.revanced.patcher.patch.annotations.processor.samples"
-
-        /**
-         * Get a source file from the given sample and class name.
-         *
-         * @param sample The sample to get the source file from.
-         * @param className The name of the class to get the source file from.
-         * @return The source file.
-         */
-        fun getSourceFile(sample: String, className: String) = SourceFile.kotlin(
-            "$className.kt", TestPatchAnnotationProcessor::class.java.classLoader.getResourceAsStream(
-                "app/revanced/patcher/patch/annotations/processor/samples/$sample/$className.kt"
-            )?.readAllBytes()?.toString(Charsets.UTF_8) ?: error("Could not find resource $className")
-        )
-
-        /**
-         * Compile the given source files and return the result.
-         *
-         * @param sourceFiles The source files to compile.
-         * @return The result of the compilation.
-         */
-        fun compile(vararg sourceFiles: SourceFile) = KotlinCompilation().apply {
-            sources = sourceFiles.asList()
-
-            symbolProcessorProviders = listOf(PatchProcessorProvider())
-
-            // Required until https://github.com/tschuchortdev/kotlin-compile-testing/issues/312 closed.
-            kspWithCompilation = true
-
-            inheritClassPath = true
-            messageOutputStream = System.out
-        }.compile().also { result ->
-            assertEquals(KotlinCompilation.ExitCode.OK, result.exitCode)
-        }
-
-        // region Class loading
-
-        fun KotlinCompilation.Result.loadPatch(name: String) = classLoader.loadClass(name).loadPatch()
-
-        fun Class<*>.loadPatch() = this.getField("INSTANCE").get(null) as Patch<*>
-
-        // endregion
-    }
-}

revanced-patch-annotations-processor/src/test/resources/app/revanced/patcher/patch/annotations/processor/samples/dependencies/DependencyPatch.kt

@@ -1,10 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor.samples.dependencies
-
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotations.Patch
-
-@Patch(name = "Dependency patch")
-object DependencyPatch : ResourcePatch() {
-    override fun execute(context: ResourceContext) {}
-}

revanced-patch-annotations-processor/src/test/resources/app/revanced/patcher/patch/annotations/processor/samples/dependencies/DependentPatch.kt

@@ -1,12 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor.samples.dependencies
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotations.Patch
-
-@Patch(
-    name = "Dependent patch",
-    dependencies = [DependencyPatch::class],
-)
-object DependentPatch : BytecodePatch() {
-    override fun execute(context: BytecodeContext) {}
-}

revanced-patch-annotations-processor/src/test/resources/app/revanced/patcher/patch/annotations/processor/samples/limitations/manualdependency/DependencyPatch.kt

@@ -1,10 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor.samples.limitations.manualdependency
-
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotations.Patch
-
-@Patch(name = "Dependency patch")
-object DependencyPatch : ResourcePatch() {
-    override fun execute(context: ResourceContext) { }
-}

revanced-patch-annotations-processor/src/test/resources/app/revanced/patcher/patch/annotations/processor/samples/limitations/manualdependency/DependentPatch.kt

@@ -1,17 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor.samples.limitations.manualdependency
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotations.Patch
-
-@Patch(name = "Dependent patch")
-object DependentPatch : BytecodePatch(
-    // Dependency will not be executed correctly if it is manually specified.
-    // The reason for this is that the dependency patch is annotated too,
-    // so the processor will generate a new patch class for it embedding the annotated information.
-    // Because the dependency is manually specified,
-    // the processor will not be able to change this dependency to the generated class,
-    // which means that the dependency will lose the annotated information.
-    dependencies = setOf(DependencyPatch::class)
-) {
-    override fun execute(context: BytecodeContext) {}
-}

revanced-patch-annotations-processor/src/test/resources/app/revanced/patcher/patch/annotations/processor/samples/options/OptionsPatch.kt

@@ -1,21 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor.samples.options
-
-import app.revanced.patcher.data.ResourceContext
-import app.revanced.patcher.patch.PatchOption
-import app.revanced.patcher.patch.ResourcePatch
-import app.revanced.patcher.patch.annotations.Patch
-
-@Patch(name = "Options patch")
-object OptionsPatch : ResourcePatch() {
-    override fun execute(context: ResourceContext) {}
-
-    @Suppress("unused")
-    private val printOption by option(
-        PatchOption.StringOption(
-            "print",
-            null,
-            "Print message",
-            "The message to print."
-        )
-    )
-}

revanced-patch-annotations-processor/src/test/resources/app/revanced/patcher/patch/annotations/processor/samples/processing/ProcessablePatch.kt

@@ -1,10 +0,0 @@
-package app.revanced.patcher.patch.annotations.processor.samples.processing
-
-import app.revanced.patcher.data.BytecodeContext
-import app.revanced.patcher.patch.BytecodePatch
-import app.revanced.patcher.patch.annotations.Patch
-
-@Patch("Processable patch")
-object ProcessablePatch : BytecodePatch() {
-    override fun execute(context: BytecodeContext) {}
-}

revanced-patcher/build.gradle.kts

@@ -1,58 +0,0 @@
-plugins {
-    kotlin("jvm") version "1.9.0"
-    `maven-publish`
-}
-
-group = "app.revanced"
-
-dependencies {
-    implementation(libs.kotlinx.coroutines.core)
-    implementation(libs.xpp3)
-    implementation(libs.smali)
-    implementation(libs.multidexlib2)
-    implementation(libs.apktool.lib)
-    implementation(libs.kotlin.reflect)
-
-    compileOnly(libs.android)
-
-    testImplementation(project(":revanced-patch-annotations-processor"))
-    testImplementation(libs.kotlin.test)
-}
-
-tasks {
-    test {
-        useJUnitPlatform()
-        testLogging {
-            events("PASSED", "SKIPPED", "FAILED")
-        }
-    }
-
-    processResources {
-        expand("projectVersion" to project.version)
-    }
-}
-
-kotlin { jvmToolchain(11) }
-
-java {
-    withSourcesJar()
-}
-
-publishing {
-    repositories {
-        mavenLocal()
-        maven {
-            name = "GitHubPackages"
-            url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
-            credentials {
-                username = System.getenv("GITHUB_ACTOR")
-                password = System.getenv("GITHUB_TOKEN")
-            }
-        }
-    }
-    publications {
-        create<MavenPublication>("gpr") {
-            from(components["java"])
-        }
-    }
-}

revanced-patcher/settings.gradle.kts

@@ -1 +0,0 @@
-rootProject.name = "revanced-patcher"

revanced-patcher/src/main/kotlin/app/revanced/patcher/fingerprint/Fingerprint.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.fingerprint
-
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
-
-/**
- * A ReVanced fingerprint.
- * Can be a [MethodFingerprint].
- */
-interface Fingerprint

revanced-patcher/src/main/kotlin/app/revanced/patcher/logging/Logger.kt

@@ -1,9 +0,0 @@
-package app.revanced.patcher.logging
-
-@Deprecated("This will be removed in a future release")
-interface Logger {
-    fun error(msg: String) {}
-    fun warn(msg: String) {}
-    fun info(msg: String) {}
-    fun trace(msg: String) {}
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/logging/impl/NopLogger.kt

@@ -1,6 +0,0 @@
-package app.revanced.patcher.logging.impl
-
-import app.revanced.patcher.logging.Logger
-
-@Deprecated("This will be removed in a future release")
-object NopLogger : Logger

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

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

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

@@ -1,109 +0,0 @@
-@file:Suppress("MemberVisibilityCanBePrivate", "UNUSED_PARAMETER")
-
-package app.revanced.patcher.patch
-
-import app.revanced.patcher.PatchClass
-import app.revanced.patcher.Patcher
-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.
- *
- * If an implementation of [Patch] also implements [Closeable]
- * it will be closed in reverse execution order of patches executed by ReVanced [Patcher].
- *
- * @param name The name of the patch.
- * @param description The description of the patch.
- * @param compatiblePackages The packages the patch is compatible with.
- * @param dependencies The names of patches this patch depends on.
- * @param use Weather or not the patch should be used.
- * @param requiresIntegrations Weather or not the patch requires integrations.
- * @param T The [Context] type this patch will work on.
- */
-sealed class Patch<out T : Context<*>>(
-    val name: String? = null,
-    val description: String? = null,
-    val compatiblePackages: Set<CompatiblePackage>? = null,
-    val dependencies: Set<PatchClass>? = null,
-    val use: Boolean = true,
-    // TODO: Remove this property, once integrations are coupled with patches.
-    val requiresIntegrations: Boolean = false,
-) : OptionsContainer() {
-    /**
-     * The execution function of the patch.
-     *
-     * @param context The [Context] the patch will work on.
-     * @return The result of executing the patch.
-     */
-    abstract fun execute(context: @UnsafeVariance T)
-
-    override fun hashCode() = name.hashCode()
-
-    override fun toString() = name ?: this::class.simpleName ?: "Unnamed patch"
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (javaClass != other?.javaClass) return false
-
-        other as Patch<*>
-
-        return name == other.name
-    }
-
-    /**
-     * A package a [Patch] is compatible with.
-     *
-     * @param name The name of the package.
-     * @param versions The versions of the package.
-     */
-    class CompatiblePackage(
-        val name: String,
-        versions: Set<String>? = null,
-    )
-}
-
-/**
- * A ReVanced [Patch] that works on [ResourceContext].
- *
- * @param name The name of the patch.
- * @param description The description of the patch.
- * @param compatiblePackages The packages the patch is compatible with.
- * @param dependencies The names of patches this patch depends on.
- * @param use Weather or not the patch should be used.
- * @param requiresIntegrations Weather or not the patch requires integrations.
- */
-abstract class ResourcePatch(
-    name: String? = null,
-    description: String? = null,
-    compatiblePackages: Set<CompatiblePackage>? = null,
-    dependencies: Set<PatchClass>? = null,
-    use: Boolean = true,
-    // TODO: Remove this property, once integrations are coupled with patches.
-    requiresIntegrations: Boolean = false,
-) : Patch<ResourceContext>(name, description, compatiblePackages, dependencies, use, requiresIntegrations)
-
-/**
- * A ReVanced [Patch] that works on [BytecodeContext].
- *
- * @param fingerprints A list of [MethodFingerprint]s which will be resolved before the patch is executed.
- * @param name The name of the patch.
- * @param description The description of the patch.
- * @param compatiblePackages The packages the patch is compatible with.
- * @param dependencies The names of patches this patch depends on.
- * @param use Weather or not the patch should be used.
- * @param requiresIntegrations Weather or not the patch requires integrations.
- */
-abstract class BytecodePatch(
-    internal val fingerprints: Set<MethodFingerprint> = emptySet(),
-    name: String? = null,
-    description: String? = null,
-    compatiblePackages: Set<CompatiblePackage>? = null,
-    dependencies: Set<PatchClass>? = null,
-    use: Boolean = true,
-    // TODO: Remove this property, once integrations are coupled with patches.
-    requiresIntegrations: Boolean = false,
-) : Patch<BytecodeContext>(name, description, compatiblePackages, dependencies, use, requiresIntegrations)

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

@@ -1,230 +0,0 @@
-@file:Suppress("CanBeParameter", "MemberVisibilityCanBePrivate", "UNCHECKED_CAST")
-
-package app.revanced.patcher.patch
-
-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`_
- * @param default The default value of the option.
- * @param title A human-readable title of the option. Example: _Patch Settings_
- * @param description A human-readable description of the option. Example: _Settings for the patches._
- * @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
-    )
-}

revanced-patcher/src/main/kotlin/app/revanced/patcher/patch/PatchResult.kt

@@ -1,20 +0,0 @@
-package app.revanced.patcher.patch
-
-/**
- * A result of executing a [Patch].
- *
- * @param patch The [Patch] that was executed.
- * @param exception The [PatchException] thrown, if any.
- */
-@Suppress("MemberVisibilityCanBePrivate")
-class PatchResult internal constructor(val patch: Patch<*>, val exception: PatchException? = null) {
-    override fun hashCode() = patch.hashCode()
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (javaClass != other?.javaClass) return false
-
-        other as PatchResult
-
-        return patch == other.patch
-    }
-}

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

@@ -1,18 +0,0 @@
-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)
-    }
-}

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

@@ -1,109 +0,0 @@
-package app.revanced.patcher.patch
-
-import app.revanced.patcher.usage.ExampleBytecodePatch
-import org.junit.jupiter.api.assertThrows
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotEquals
-import kotlin.test.assertNotNull
-
-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) {
-                        assertNotNull(choice)
-                    }
-                }
-
-                is PatchOption.IntListOption -> {
-                    option.value = option.options.first()
-                    for (choice in option.options) {
-                        assertNotNull(choice)
-                    }
-                }
-            }
-        }
-        val option = options.get<String>("key1")
-        // or: val option: String? by options["key1"]
-        // then you won't need `.value` every time
-        assertEquals("Hello World", option.value)
-        options["key1"] = "Hello, world!"
-        assertEquals("Hello, world!", 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> {
-            options["key5"].value
-        }
-    }
-}