external/revanced-patcher
1
0
Fork 0
mirror of https://github.com/ReVanced/revanced-patcher.git synced 2024-11-10 01:02:22 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #33 from revanced/annotations

Browse source 
feat: use annotations instead of metadata objects
This commit is contained in:
oSumAtrIX 2022-05-22 17:14:48 +02:00 committed by GitHub
commit 0873703056
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
56 changed files with 521 additions and 376 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
build.gradle.kts
View file

@ -29,6 +29,7 @@ dependencies {
api("org.smali:smali:2.5.2")
testImplementation(kotlin("test"))
implementation(kotlin("reflect"))
}
tasks {

25
src/main/kotlin/app/revanced/patcher/Patcher.kt
View file

@ -1,15 +1,16 @@
package app.revanced.patcher
import app.revanced.patcher.annotation.Name
import app.revanced.patcher.data.PatcherData
import app.revanced.patcher.data.base.Data
import app.revanced.patcher.data.implementation.findIndexed
import app.revanced.patcher.extensions.findAnnotationRecursively
import app.revanced.patcher.patch.base.Patch
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.PatchResultSuccess
import app.revanced.patcher.signature.MethodSignature
import app.revanced.patcher.signature.resolver.SignatureResolver
import app.revanced.patcher.signature.implementation.method.MethodSignature
import app.revanced.patcher.signature.implementation.method.resolver.MethodSignatureResolver
import app.revanced.patcher.util.ListBackedSet
import brut.androlib.Androlib
import brut.androlib.meta.UsesFramework
@ -159,11 +160,12 @@ class Patcher(
return emptyList()
}
SignatureResolver(patcherData.bytecodeData.classes.internalClasses, signatures).resolve(patcherData)
MethodSignatureResolver(patcherData.bytecodeData.classes.internalClasses, signatures).resolve(patcherData)
signaturesResolved = true
return signatures
}
/**
* Apply patches loaded into the patcher.
* @param stopOnError If true, the patches will stop on the first error.
@ -174,7 +176,7 @@ class Patcher(
fun applyPatches(
stopOnError: Boolean = false,
callback: (String) -> Unit = {}
): Map<PatchMetadata, Result<PatchResultSuccess>> {
): Map<String, Result<PatchResultSuccess>> {
if (!signaturesResolved) {
resolveSignatures()
}
@ -183,7 +185,12 @@ class Patcher(
val resourcePatch = patch is ResourcePatch
if (!patchResources && resourcePatch) continue
callback(patch.metadata.shortName)
val patchNameAnnotation = patch::class.java.findAnnotationRecursively(Name::class.java)
patchNameAnnotation?.let {
callback(it.name)
}
val result: Result<PatchResultSuccess> = try {
val data = if (resourcePatch) {
patcherData.resourceData
@ -201,7 +208,11 @@ class Patcher(
} catch (e: Exception) {
Result.failure(e)
}
this[patch.metadata] = result
patchNameAnnotation?.let {
this[patchNameAnnotation.name] = result
}
if (result.isFailure && stopOnError) break
}
}

28
src/main/kotlin/app/revanced/patcher/annotation/CompatibilityAnnotation.kt Normal file
View file

@ -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>
)

38
src/main/kotlin/app/revanced/patcher/annotation/MetadataAnnotation.kt Normal file
View file

@ -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,
)

11
src/main/kotlin/app/revanced/patcher/data/implementation/BytecodeData.kt
View file

@ -1,12 +1,11 @@
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.signature.implementation.method.resolver.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
@ -28,7 +27,7 @@ class BytecodeData(
* Find a class by a given predicate
* @return A proxy for the first class that matches the predicate
*/
fun findClass(predicate: (ClassDef) -> Boolean): ClassProxy? {
fun findClass(predicate: (ClassDef) -> Boolean): app.revanced.patcher.util.proxy.ClassProxy? {
// if we already proxied the class matching the predicate...
for (patch in patches) {
if (patch !is BytecodePatch) continue
@ -77,10 +76,10 @@ 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)
}
return proxy

29
src/main/kotlin/app/revanced/patcher/extensions/Extensions.kt
View file

@ -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
@ -10,6 +10,33 @@ import org.jf.dexlib2.immutable.ImmutableMethod
import org.jf.dexlib2.immutable.ImmutableMethodImplementation
import org.jf.dexlib2.util.MethodUtil
/**
* Recursively find a given annotation on a class
* @param targetAnnotation The annotation to find
* @return The annotation
*/
fun <T : Annotation> Class<*>.findAnnotationRecursively(targetAnnotation: Class<T>) =
this.findAnnotationRecursively(targetAnnotation, 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
}
infix fun AccessFlags.or(other: AccessFlags) = this.value or other.value
infix fun Int.or(other: AccessFlags) = this or other.value

9
src/main/kotlin/app/revanced/patcher/patch/annotations/PatchAnnotation.kt Normal file
View file

@ -0,0 +1,9 @@
package app.revanced.patcher.patch.annotations
/**
* Annotation to mark a Class as a patch.
*/
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
@MustBeDocumented
annotation class Patch

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

@ -3,20 +3,16 @@ 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>(
open val metadata: PatchMetadata
) {
abstract class Patch<out T : Data> {
/**
* The main function of the [Patch] which the patcher will call.
*/
abstract fun execute(data: @UnsafeVariance T): PatchResult // FIXME: remove the UnsafeVariance annotation
}

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

@ -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.MethodSignature
import app.revanced.patcher.signature.implementation.method.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>()

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

@ -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(
override val metadata: PatchMetadata
) : Patch<ResourceData>(metadata)
abstract class ResourcePatch : Patch<ResourceData>()

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

@ -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>
)

111
src/main/kotlin/app/revanced/patcher/signature/MethodSignature.kt
View file

@ -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,
)
}
}

48
src/main/kotlin/app/revanced/patcher/signature/SignatureResolverResult.kt
View file

@ -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
)

9
src/main/kotlin/app/revanced/patcher/signature/base/Signature.kt Normal file
View file

@ -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

47
src/main/kotlin/app/revanced/patcher/signature/implementation/method/MethodSignature.kt Normal file
View file

@ -0,0 +1,47 @@
package app.revanced.patcher.signature.implementation.method
import app.revanced.patcher.annotation.Name
import app.revanced.patcher.data.implementation.MethodNotFoundException
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
get() {
return field ?: throw MethodNotFoundException(
"Could not resolve required signature ${
(this::class.annotations.find { it is Name }?.let {
(it as Name).name
})
}"
)
}
val resolved: Boolean
get() {
var resolved = false
try {
resolved = result != null
} catch (_: Exception) {
}
return resolved
}
}

32
src/main/kotlin/app/revanced/patcher/signature/implementation/method/annotation/MethodSignatureMetadata.kt Normal file
View file

@ -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

34
src/main/kotlin/app/revanced/patcher/signature/resolver/SignatureResolver.kt → src/main/kotlin/app/revanced/patcher/signature/implementation/method/resolver/MethodSignatureResolver.kt
View file

@ -1,13 +1,11 @@
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.findAnnotationRecursively
import app.revanced.patcher.extensions.parametersEqual
import app.revanced.patcher.proxy.ClassProxy
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 app.revanced.patcher.signature.implementation.method.MethodSignature
import app.revanced.patcher.signature.implementation.method.annotation.FuzzyPatternScanMethod
import org.jf.dexlib2.Opcode
import org.jf.dexlib2.iface.ClassDef
import org.jf.dexlib2.iface.Method
@ -15,7 +13,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 +37,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(
@ -107,9 +108,10 @@ 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)
method.threshold else 0
val threshold =
signature::class.java.findAnnotationRecursively(FuzzyPatternScanMethod::class.java)?.threshold
?: 0
for (instructionIndex in 0 until count) {
var patternIndex = 0
@ -126,11 +128,9 @@ internal class SignatureResolver(
patternIndex-- // fix pattern offset
val result = PatternScanResult(instructionIndex, instructionIndex + patternIndex)
if (method is PatternScanMethod.Fuzzy) {
method.warnings = generateWarnings(
signature, instructions, result
)
}
result.warnings = generateWarnings(signature, instructions, result)
return result
}
}
@ -152,7 +152,7 @@ internal class SignatureResolver(
correctOpcode != patternOpcode
) {
this.add(
PatternScanMethod.Fuzzy.Warning(
PatternScanResult.Warning(
correctOpcode, patternOpcode,
instructionIndex, patternIndex,
)

75
src/main/kotlin/app/revanced/patcher/signature/implementation/method/resolver/MethodSignatureResolverResult.kt Normal file
View file

@ -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,
)
}

2
src/main/kotlin/app/revanced/patcher/util/ListBackedSet.kt
View file

@ -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)

5
src/main/kotlin/app/revanced/patcher/util/ProxyBackedClassList.kt
View file

@ -1,16 +1,15 @@
package app.revanced.patcher.util
import app.revanced.patcher.proxy.ClassProxy
import org.jf.dexlib2.iface.ClassDef
class ProxyBackedClassList(internal val internalClasses: MutableList<ClassDef>) : List<ClassDef> {
internal val proxies = mutableListOf<ClassProxy>()
internal val proxies = mutableListOf<app.revanced.patcher.util.proxy.ClassProxy>()
fun add(classDef: ClassDef) {
internalClasses.add(classDef)
}
fun add(classProxy: ClassProxy) {
fun add(classProxy: app.revanced.patcher.util.proxy.ClassProxy) {
proxies.add(classProxy)
}

4
src/main/kotlin/app/revanced/patcher/methodWalker/MethodWalker.kt → src/main/kotlin/app/revanced/patcher/util/method/MethodWalker.kt
View file

@ -1,9 +1,9 @@
package app.revanced.patcher.methodWalker
package app.revanced.patcher.util.method
import app.revanced.patcher.data.implementation.BytecodeData
import app.revanced.patcher.data.implementation.MethodNotFoundException
import app.revanced.patcher.extensions.softCompareTo
import app.revanced.patcher.proxy.mutableTypes.MutableMethod
import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
import org.jf.dexlib2.Format
import org.jf.dexlib2.iface.Method
import org.jf.dexlib2.iface.instruction.formats.Instruction35c

34
src/main/kotlin/app/revanced/patcher/util/patch/PatchLoader.kt Normal file
View file

@ -0,0 +1,34 @@
package app.revanced.patcher.util.patch
import app.revanced.patcher.patch.base.Patch
import java.io.File
import java.net.URLClassLoader
import java.util.jar.JarFile
object PatchLoader {
/**
* This method loads patches from a given jar file containing [Patch]es
* @return the loaded patches represented as a list of [Patch] classes
*/
fun loadFromFile(patchesJar: File) = buildList {
val jarFile = JarFile(patchesJar)
val classLoader = URLClassLoader(arrayOf(patchesJar.toURI().toURL()))
val entries = jarFile.entries()
while (entries.hasMoreElements()) {
val entry = entries.nextElement()
if (!entry.name.endsWith(".class") || entry.name.contains("$")) continue
val clazz = classLoader.loadClass(entry.realName.replace('/', '.').replace(".class", ""))
if (!clazz.isAnnotationPresent(app.revanced.patcher.patch.annotations.Patch::class.java)) continue
@Suppress("UNCHECKED_CAST")
val patch = clazz as Class<Patch<*>>
// TODO: include declared classes from patch
this.add(patch)
}
}
}

4
src/main/kotlin/app/revanced/patcher/proxy/ClassProxy.kt → src/main/kotlin/app/revanced/patcher/util/proxy/ClassProxy.kt
View file

@ -1,6 +1,6 @@
package app.revanced.patcher.proxy
package app.revanced.patcher.util.proxy
import app.revanced.patcher.proxy.mutableTypes.MutableClass
import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
import org.jf.dexlib2.iface.ClassDef
/**

4
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableAnnotation.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotation.kt
View file

@ -1,6 +1,6 @@
package app.revanced.patcher.proxy.mutableTypes
package app.revanced.patcher.util.proxy.mutableTypes
import app.revanced.patcher.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
import org.jf.dexlib2.base.BaseAnnotation
import org.jf.dexlib2.iface.Annotation

6
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableAnnotationElement.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableAnnotationElement.kt
View file

@ -1,7 +1,7 @@
package app.revanced.patcher.proxy.mutableTypes
package app.revanced.patcher.util.proxy.mutableTypes
import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue
import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue
import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
import org.jf.dexlib2.base.BaseAnnotationElement
import org.jf.dexlib2.iface.AnnotationElement
import org.jf.dexlib2.iface.value.EncodedValue

8
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableClass.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableClass.kt
View file

@ -1,8 +1,8 @@
package app.revanced.patcher.proxy.mutableTypes
package app.revanced.patcher.util.proxy.mutableTypes
import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import app.revanced.patcher.proxy.mutableTypes.MutableField.Companion.toMutable
import app.revanced.patcher.proxy.mutableTypes.MutableMethod.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
import com.google.common.collect.Iterables
import org.jf.dexlib2.base.reference.BaseTypeReference
import org.jf.dexlib2.iface.ClassDef

8
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableField.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableField.kt
View file

@ -1,8 +1,8 @@
package app.revanced.patcher.proxy.mutableTypes
package app.revanced.patcher.util.proxy.mutableTypes
import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue
import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue
import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
import org.jf.dexlib2.HiddenApiRestriction
import org.jf.dexlib2.base.reference.BaseFieldReference
import org.jf.dexlib2.iface.Field

6
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableMethod.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableMethod.kt
View file

@ -1,7 +1,7 @@
package app.revanced.patcher.proxy.mutableTypes
package app.revanced.patcher.util.proxy.mutableTypes
import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import app.revanced.patcher.proxy.mutableTypes.MutableMethodParameter.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableMethodParameter.Companion.toMutable
import org.jf.dexlib2.HiddenApiRestriction
import org.jf.dexlib2.base.reference.BaseMethodReference
import org.jf.dexlib2.builder.MutableMethodImplementation

4
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/MutableMethodParameter.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/MutableMethodParameter.kt
View file

@ -1,6 +1,6 @@
package app.revanced.patcher.proxy.mutableTypes
package app.revanced.patcher.util.proxy.mutableTypes
import app.revanced.patcher.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotation.Companion.toMutable
import org.jf.dexlib2.base.BaseMethodParameter
import org.jf.dexlib2.iface.MethodParameter

4
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableAnnotationEncodedValue.kt
View file

@ -1,6 +1,6 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import app.revanced.patcher.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableAnnotationElement.Companion.toMutable
import org.jf.dexlib2.base.value.BaseAnnotationEncodedValue
import org.jf.dexlib2.iface.AnnotationElement
import org.jf.dexlib2.iface.value.AnnotationEncodedValue

4
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableArrayEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableArrayEncodedValue.kt
View file

@ -1,6 +1,6 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import app.revanced.patcher.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.encodedValue.MutableEncodedValue.Companion.toMutable
import org.jf.dexlib2.base.value.BaseArrayEncodedValue
import org.jf.dexlib2.iface.value.ArrayEncodedValue
import org.jf.dexlib2.iface.value.EncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableBooleanEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseBooleanEncodedValue
import org.jf.dexlib2.iface.value.BooleanEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableByteEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableByteEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseByteEncodedValue
import org.jf.dexlib2.iface.value.ByteEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableCharEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableCharEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseCharEncodedValue
import org.jf.dexlib2.iface.value.CharEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableDoubleEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseDoubleEncodedValue
import org.jf.dexlib2.iface.value.DoubleEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.ValueType
import org.jf.dexlib2.iface.value.*

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableEnumEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableEnumEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseEnumEncodedValue
import org.jf.dexlib2.iface.reference.FieldReference

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableFieldEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFieldEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.ValueType
import org.jf.dexlib2.base.value.BaseFieldEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableFloatEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseFloatEncodedValue
import org.jf.dexlib2.iface.value.FloatEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableIntEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableIntEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseIntEncodedValue
import org.jf.dexlib2.iface.value.IntEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableLongEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableLongEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseLongEncodedValue
import org.jf.dexlib2.iface.value.LongEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseMethodEncodedValue
import org.jf.dexlib2.iface.reference.MethodReference

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodHandleEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseMethodHandleEncodedValue
import org.jf.dexlib2.iface.reference.MethodHandleReference

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableMethodTypeEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseMethodTypeEncodedValue
import org.jf.dexlib2.iface.reference.MethodProtoReference

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableNullEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableNullEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseNullEncodedValue
import org.jf.dexlib2.iface.value.ByteEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableShortEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableShortEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseShortEncodedValue
import org.jf.dexlib2.iface.value.ShortEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableStringEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableStringEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseStringEncodedValue
import org.jf.dexlib2.iface.value.ByteEncodedValue

2
src/main/kotlin/app/revanced/patcher/proxy/mutableTypes/encodedValue/MutableTypeEncodedValue.kt → src/main/kotlin/app/revanced/patcher/util/proxy/mutableTypes/encodedValue/MutableTypeEncodedValue.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.proxy.mutableTypes.encodedValue
package app.revanced.patcher.util.proxy.mutableTypes.encodedValue
import org.jf.dexlib2.base.value.BaseTypeEncodedValue
import org.jf.dexlib2.iface.value.TypeEncodedValue

15
src/main/kotlin/app/revanced/patcher/smali/InlineSmaliCompiler.kt → src/main/kotlin/app/revanced/patcher/util/smali/InlineSmaliCompiler.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.smali
package app.revanced.patcher.util.smali
import org.antlr.runtime.CommonTokenStream
import org.antlr.runtime.TokenSource
@ -32,7 +32,11 @@ class InlineSmaliCompiler {
* be messed up and results in broken Dalvik bytecode.
* FIXME: Fix the above issue. When this is fixed, add the proper conversions in [InstructionConverter].
*/
fun compileMethodInstructions(instructions: String, parameters: String, registers: Int): List<BuilderInstruction> {
fun compileMethodInstructions(
instructions: String,
parameters: String,
registers: Int
): List<BuilderInstruction> {
val input = METHOD_TEMPLATE.format(parameters, registers, instructions)
val reader = InputStreamReader(input.byteInputStream())
val lexer: LexerErrorInterface = smaliFlexLexer(reader, 15)
@ -54,5 +58,8 @@ class InlineSmaliCompiler {
}
}
fun String.toInstructions(parameters: String = "", registers: Int = 1) = InlineSmaliCompiler.compileMethodInstructions(this, parameters, registers)
fun String.toInstruction(parameters: String = "", registers: Int = 1) = this.toInstructions(parameters, registers).first()
fun String.toInstructions(parameters: String = "", registers: Int = 1) =
InlineSmaliCompiler.compileMethodInstructions(this, parameters, registers)
fun String.toInstruction(parameters: String = "", registers: Int = 1) =
this.toInstructions(parameters, registers).first()

2
src/main/kotlin/app/revanced/patcher/smali/InstructionConverter.kt → src/main/kotlin/app/revanced/patcher/util/smali/InstructionConverter.kt
View file

@ -1,4 +1,4 @@
package app.revanced.patcher.smali
package app.revanced.patcher.util.smali
import org.jf.dexlib2.Format
import org.jf.dexlib2.builder.instruction.*

53
src/test/kotlin/app/revanced/patcher/PatcherTest.kt
View file

@ -1,49 +1,46 @@
package app.revanced.patcher
import app.revanced.patcher.signature.PatternScanMethod
import app.revanced.patcher.usage.ExampleBytecodePatch
import app.revanced.patcher.usage.ExampleResourcePatch
import org.junit.jupiter.api.Test
import java.io.File
import kotlin.test.assertTrue
internal class PatcherTest {
@Test
fun testPatcher() {
return // FIXME: create a proper resource to pass this test
/**
val patcher = Patcher(
File(PatcherTest::class.java.getResource("/example.apk")!!.toURI()),
"exampleCacheDirectory",
patchResources = true
File(PatcherTest::class.java.getResource("/example.apk")!!.toURI()),
"exampleCacheDirectory",
patchResources = true
)
patcher.addPatches(listOf(ExampleBytecodePatch(), ExampleResourcePatch()))
for (signature in patcher.resolveSignatures()) {
if (!signature.resolved) {
throw Exception("Signature ${signature.metadata.name} was not resolved!")
}
val patternScanMethod = signature.metadata.patternScanMethod
if (patternScanMethod is PatternScanMethod.Fuzzy) {
val warnings = patternScanMethod.warnings
if (warnings != null) {
println("Signature ${signature.metadata.name} had ${warnings.size} warnings!")
for (warning in warnings) {
println(warning.toString())
}
} else {
println("Signature ${signature.metadata.name} used the fuzzy resolver, but the warnings list is null!")
}
}
if (!signature.resolved) {
throw Exception("Signature ${signature.metadata.name} was not resolved!")
}
val patternScanMethod = signature.metadata.patternScanMethod
if (patternScanMethod is PatternScanMethod.Fuzzy) {
val warnings = patternScanMethod.warnings
if (warnings != null) {
println("Signature ${signature.metadata.name} had ${warnings.size} warnings!")
for (warning in warnings) {
println(warning.toString())
}
} else {
println("Signature ${signature.metadata.name} used the fuzzy resolver, but the warnings list is null!")
}
}
}
for ((metadata, result) in patcher.applyPatches()) {
if (result.isFailure) {
throw Exception("Patch ${metadata.shortName} failed", result.exceptionOrNull()!!)
} else {
println("Patch ${metadata.shortName} applied successfully!")
}
if (result.isFailure) {
throw Exception("Patch ${metadata.shortName} failed", result.exceptionOrNull()!!)
} else {
println("Patch ${metadata.shortName} applied successfully!")
}
}
val out = patcher.save()
assertTrue(out.isNotEmpty(), "Expected the output of Patcher#save() to not be empty.")
*/
}
}

14
src/test/kotlin/app/revanced/patcher/usage/bytecode/annotation/ExampleBytecodeCompatibility.kt Normal file
View file

@ -0,0 +1,14 @@
package app.revanced.patcher.usage.bytecode.annotation
import app.revanced.patcher.annotation.Compatibility
import app.revanced.patcher.annotation.Package
@Compatibility(
[Package(
"com.example.examplePackage", arrayOf("0.0.1", "0.0.2")
)]
)
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
internal annotation class ExampleBytecodeCompatibility

70
src/test/kotlin/app/revanced/patcher/usage/ExampleBytecodePatch.kt → src/test/kotlin/app/revanced/patcher/usage/bytecode/patch/ExampleBytecodePatch.kt
View file

@ -1,21 +1,21 @@
package app.revanced.patcher.usage
package app.revanced.patcher.usage.bytecode.patch
import app.revanced.patcher.annotation.Description
import app.revanced.patcher.annotation.Name
import app.revanced.patcher.annotation.Version
import app.revanced.patcher.data.implementation.BytecodeData
import app.revanced.patcher.extensions.addInstructions
import app.revanced.patcher.extensions.or
import app.revanced.patcher.patch.annotations.Patch
import app.revanced.patcher.patch.implementation.BytecodePatch
import app.revanced.patcher.patch.implementation.metadata.PackageMetadata
import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
import app.revanced.patcher.patch.implementation.misc.PatchResult
import app.revanced.patcher.patch.implementation.misc.PatchResultSuccess
import app.revanced.patcher.proxy.mutableTypes.MutableField.Companion.toMutable
import app.revanced.patcher.proxy.mutableTypes.MutableMethod.Companion.toMutable
import app.revanced.patcher.signature.MethodMetadata
import app.revanced.patcher.signature.MethodSignature
import app.revanced.patcher.signature.MethodSignatureMetadata
import app.revanced.patcher.signature.PatternScanMethod
import app.revanced.patcher.smali.toInstruction
import app.revanced.patcher.smali.toInstructions
import app.revanced.patcher.usage.bytecode.signatures.ExampleSignature
import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
import app.revanced.patcher.util.proxy.mutableTypes.MutableField.Companion.toMutable
import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod.Companion.toMutable
import app.revanced.patcher.util.smali.toInstruction
import app.revanced.patcher.util.smali.toInstructions
import com.google.common.collect.ImmutableList
import org.jf.dexlib2.AccessFlags
import org.jf.dexlib2.Format
@ -32,45 +32,15 @@ import org.jf.dexlib2.immutable.reference.ImmutableStringReference
import org.jf.dexlib2.immutable.value.ImmutableFieldEncodedValue
import org.jf.dexlib2.util.Preconditions
val packageMetadata = listOf(
PackageMetadata(
"com.example.examplePackage",
listOf("0.0.1", "0.0.2")
)
)
@Patch
@Name("example-bytecode-patch")
@Description("Example demonstration of a bytecode patch.")
@ExampleResourceCompatibility
@Version("0.0.1")
class ExampleBytecodePatch : BytecodePatch(
PatchMetadata(
"example-patch",
"ReVanced example patch",
"A demonstrative patch to feature the core features of the ReVanced patcher",
packageMetadata,
"0.0.1"
),
setOf(
MethodSignature(
MethodSignatureMetadata(
"Example signature",
MethodMetadata(
"TestClass",
"main",
),
PatternScanMethod.Fuzzy(1),
packageMetadata,
"The main method of TestClass",
"1.0.0"
),
"V",
AccessFlags.PUBLIC or AccessFlags.STATIC,
listOf("[L"),
listOf(
Opcode.SGET_OBJECT,
null, // Testing unknown opcodes.
Opcode.INVOKE_STATIC, // This is intentionally wrong to test the Fuzzy resolver.
Opcode.RETURN_VOID
),
null
)
listOf(
ExampleSignature
)
) {
// This function will be executed by the patcher.
@ -85,7 +55,7 @@ class ExampleBytecodePatch : BytecodePatch(
// Let's modify it, so it prints "Hello, ReVanced! Editing bytecode."
// Get the start index of our opcode pattern.
// This will be the index of the instruction with the opcode CONST_STRING.
val startIndex = result.scanData.startIndex
val startIndex = result.scanResult.startIndex
implementation.replaceStringAt(startIndex, "Hello, ReVanced! Editing bytecode.")

32
src/test/kotlin/app/revanced/patcher/usage/bytecode/signatures/ExampleSignature.kt Normal file
View file

@ -0,0 +1,32 @@
package app.revanced.patcher.usage.bytecode.signatures
import app.revanced.patcher.annotation.Name
import app.revanced.patcher.annotation.Version
import app.revanced.patcher.extensions.or
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 app.revanced.patcher.usage.bytecode.annotation.ExampleBytecodeCompatibility
import org.jf.dexlib2.AccessFlags
import org.jf.dexlib2.Opcode
@Name("example-signature")
@MatchingMethod(
"LexampleClass;",
"exampleMehod"
)
@FuzzyPatternScanMethod(2)
@ExampleBytecodeCompatibility
@Version("0.0.1")
object ExampleSignature : MethodSignature(
"V",
AccessFlags.PUBLIC or AccessFlags.STATIC,
listOf("[L"),
listOf(
Opcode.SGET_OBJECT,
null, // Testing unknown opcodes.
Opcode.INVOKE_STATIC, // This is intentionally wrong to test the Fuzzy resolver.
Opcode.RETURN_VOID
),
null
)

14
src/test/kotlin/app/revanced/patcher/usage/resource/annotation/ExampleResourceCompatibility.kt Normal file
View file

@ -0,0 +1,14 @@
package app.revanced.patcher.usage.resource.annotation
import app.revanced.patcher.annotation.Compatibility
import app.revanced.patcher.annotation.Package
@Compatibility(
[Package(
"com.example.examplePackage", arrayOf("0.0.1", "0.0.2")
)]
)
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
internal annotation class ExampleResourceCompatibility

23
src/test/kotlin/app/revanced/patcher/usage/ExampleResourcePatch.kt → src/test/kotlin/app/revanced/patcher/usage/resource/patch/ExampleResourcePatch.kt
View file

@ -1,21 +1,22 @@
package app.revanced.patcher.usage
package app.revanced.patcher.usage.resource.patch
import app.revanced.patcher.annotation.Description
import app.revanced.patcher.annotation.Name
import app.revanced.patcher.annotation.Version
import app.revanced.patcher.data.implementation.ResourceData
import app.revanced.patcher.patch.annotations.Patch
import app.revanced.patcher.patch.implementation.ResourcePatch
import app.revanced.patcher.patch.implementation.metadata.PatchMetadata
import app.revanced.patcher.patch.implementation.misc.PatchResult
import app.revanced.patcher.patch.implementation.misc.PatchResultSuccess
import app.revanced.patcher.usage.resource.annotation.ExampleResourceCompatibility
import org.w3c.dom.Element
class ExampleResourcePatch : ResourcePatch(
PatchMetadata(
"example-patch",
"Example Resource Patch",
"Example demonstration of a resource patch.",
packageMetadata,
"0.0.1"
)
) {
@Patch
@Name("example-resource-patch")
@Description("Example demonstration of a resource patch.")
@ExampleResourceCompatibility
@Version("0.0.1")
class ExampleResourcePatch : ResourcePatch() {
override fun execute(data: ResourceData): PatchResult {
val editor = data.getXmlEditor("AndroidManifest.xml")