Android Java reflection method modifiers, including hidden Java flag bits. Use java.lang.reflect.Modifier for reflection conditions. For raw DEX flags, use accessFlags with DexAccessFlags. The default match type is contains. If you need to match exactly, please use modifiers overloaded function.

modifiersMatcher

var modifiersMatcher: AccessFlagsMatcher?

name

var name: String

The method name.

----------------

nameMatcher

var nameMatcher: StringMatcher?

noneOfMatchers

var noneOfMatchers: MutableList<MethodMatcher>?

opCodes

var opCodes: Collection<Int>

This method uses consecutive OP instructions.

----------------

opCodesMatcher

var opCodesMatcher: OpCodesMatcher?

opNames

var opNames: Collection<String>

This method uses consecutive smali instructions.

----------------

paramCount

var paramCount: Int

The method parameter count.

----------------

paramsMatcher

var paramsMatcher: ParametersMatcher?

paramTypes

var paramTypes: Collection<String?>

The method parameter types fully qualified name. If set to null, it means matching any parameter type. The list implies the number of parameters.

protoShorty

var protoShorty: String

The method prototype shorty. The shorty is a string that represents the return type and parameter types of a method in a compact form. The first character represents the return type, and the rest represent parameter types.

protoShortyMatcher

var protoShortyMatcher: String?

returnType

var returnType: String

The method return type fully qualified name.

----------------

returnTypeMatcher

var returnTypeMatcher: ClassMatcher?

usingFieldsMatcher

var usingFieldsMatcher: MutableList<UsingFieldMatcher>?

usingNumbers

var usingNumbers: Collection<Number>

Numbers used by this method. Integer queries compare signed values exactly. Floating queries interpret const instructions at their 32/64-bit width, with an absolute tolerance of less than 1e-6. Arithmetic literals are integer-only. Same-sign infinities and signed zeros compare equal; NaN never matches. This does not infer the original source-language type.

usingNumbersMatcher

var usingNumbersMatcher: MutableList<NumberEncodeValueMatcher>?

usingStrings

var usingStrings: Collection<String>

Using string list. Default match type is contains, if you need to match exactly, please use usingStrings or addUsingString overloaded function for each string.

usingStringsMatcher

var usingStringsMatcher: MutableList<StringMatcher>?

Functions

accessFlags

fun accessFlags(matcher: AccessFlagsMatcher): MethodMatcher

Match raw DEX flags independently of modifiers. Both constraints may be combined.

----------------

@JvmOverloads

fun accessFlags(accessFlags: Int, matchType: MatchType = MatchType.Contains): MethodMatcher

Match raw DEX access flags, including DEX-only flags from DexAccessFlags.

----------------

addAllOf

fun addAllOf(init: MethodMatcher.() -> Unit): MethodMatcher

fun addAllOf(matcher: MethodMatcher): MethodMatcher

Add one child matcher that must also match.

----------------

addAnnotation

fun addAnnotation(init: AnnotationMatcher.() -> Unit): MethodMatcher

fun addAnnotation(annotation: AnnotationMatcher): MethodMatcher

Add method annotation matcher.

----------------

addAnyOf

fun addAnyOf(init: MethodMatcher.() -> Unit): MethodMatcher

fun addAnyOf(matcher: MethodMatcher): MethodMatcher

Add one child matcher where at least one must match.

----------------

addCaller

fun addCaller(init: MethodMatcher.() -> Unit): MethodMatcher

fun addCaller(methodDescriptor: String): MethodMatcher

fun addCaller(callerMethod: MethodMatcher): MethodMatcher

Adds a matcher for when this method is called by a specified method.

----------------

addEqString

fun addEqString(usingString: String): MethodMatcher

Add using string(fuzzy match).

----------------

addInvoke

fun addInvoke(init: MethodMatcher.() -> Unit): MethodMatcher

fun addInvoke(methodDescriptor: String): MethodMatcher

Add a matcher that calls the method corresponding to the descriptor.

----------------

fun addInvoke(invokeMethod: MethodMatcher): MethodMatcher

This method calls the matcher for the specified method.

----------------

addNoneOf

fun addNoneOf(init: MethodMatcher.() -> Unit): MethodMatcher

fun addNoneOf(matcher: MethodMatcher): MethodMatcher

Add one child matcher that must not match.

----------------

addParamType

fun addParamType(paramType: Class<*>?): MethodMatcher

fun addParamType(type: ClassMatcher?): MethodMatcher

Add method parameter type class matcher.

----------------

fun addParamType(init: ClassMatcher.() -> Unit): MethodMatcher

@JvmOverloads

fun addParamType(paramType: String?, matchType: StringMatchType = StringMatchType.Equals, ignoreCase: Boolean = false): MethodMatcher

Add method parameter type fully qualified name. If set to null, it means matching any parameter type.

addUsingField

fun addUsingField(init: UsingFieldMatcher.() -> Unit): MethodMatcher

fun addUsingField(usingField: UsingFieldMatcher): MethodMatcher

@JvmOverloads

fun addUsingField(fieldDescriptor: String, usingType: UsingType = UsingType.Any): MethodMatcher

@JvmOverloads

fun addUsingField(usingField: FieldMatcher, usingType: UsingType = UsingType.Any): MethodMatcher

Using fields matcher.

----------------

addUsingNumber

fun addUsingNumber(usingNumber: Number): MethodMatcher

Add a number matcher using the integer/floating semantics described in usingNumbers.

----------------

addUsingString

fun addUsingString(usingString: StringMatcher): MethodMatcher

Add using string matcher.

----------------

@JvmOverloads

fun addUsingString(usingString: String, matchType: StringMatchType = StringMatchType.Contains, ignoreCase: Boolean = false): MethodMatcher

Add using string.

----------------

allOf

fun allOf(vararg matchers: MethodMatcher): MethodMatcher

fun allOf(matchers: Collection<MethodMatcher>): MethodMatcher

Add child matchers that must all match.

----------------

fun allOf(init: MethodMatcherList.() -> Unit): MethodMatcher

annotationCount

fun annotationCount(count: Int): MethodMatcher

Method annotation count.

----------------

fun annotationCount(range: IntRange): MethodMatcher

fun annotationCount(min: Int = 0, max: Int = Int.MAX_VALUE): MethodMatcher

Method annotation count range.

----------------

annotations

fun annotations(init: AnnotationsMatcher.() -> Unit): MethodMatcher

fun annotations(annotations: AnnotationsMatcher): MethodMatcher

The method annotations matcher.

----------------

anyOf

fun anyOf(vararg matchers: MethodMatcher): MethodMatcher

fun anyOf(matchers: Collection<MethodMatcher>): MethodMatcher

Add child matchers where at least one must match.

----------------

fun anyOf(init: MethodMatcherList.() -> Unit): MethodMatcher

callerMethods

fun callerMethods(init: MethodsMatcher.() -> Unit): MethodMatcher

fun callerMethods(callerMethods: MethodsMatcher): MethodMatcher

The matcher for when this method is called by the specified set of methods.

----------------

declaredClass

fun declaredClass(clazz: Class<*>): MethodMatcher

The method declared class.

----------------

fun declaredClass(init: ClassMatcher.() -> Unit): MethodMatcher

fun declaredClass(declaredClass: ClassMatcher): MethodMatcher

The method declared class matcher.

----------------

@JvmOverloads

fun declaredClass(className: String, matchType: StringMatchType = StringMatchType.Equals, ignoreCase: Boolean = false): MethodMatcher

The method declared class fully qualified name.

----------------

descriptor

fun descriptor(descriptor: String): MethodMatcher

The method descriptor, specifies a unique method.

----------------

invokeMethods

fun invokeMethods(init: MethodsMatcher.() -> Unit): MethodMatcher

fun invokeMethods(invokeMethods: MethodsMatcher): MethodMatcher

This method calls the matcher for the specified methods set.

----------------

modifiers

fun modifiers(modifiers: AccessFlagsMatcher): MethodMatcher

Java reflection method modifiers matcher.

----------------

@JvmOverloads

fun modifiers(modifiers: Int, matchType: MatchType = MatchType.Contains): MethodMatcher

Android Java reflection method modifiers, including hidden Java flag bits. Use java.lang.reflect.Modifier for reflection conditions. For raw DEX flags, use accessFlags with DexAccessFlags.

name

fun name(name: StringMatcher): MethodMatcher

The method name matcher

----------------

@JvmOverloads

fun name(name: String, matchType: StringMatchType = StringMatchType.Equals, ignoreCase: Boolean = false): MethodMatcher

The method name.

----------------

noneOf

fun noneOf(vararg matchers: MethodMatcher): MethodMatcher

fun noneOf(matchers: Collection<MethodMatcher>): MethodMatcher

Add child matchers that must not match.

----------------

fun noneOf(init: MethodMatcherList.() -> Unit): MethodMatcher

not

fun not(init: MethodMatcher.() -> Unit): MethodMatcher

fun not(matcher: MethodMatcher): MethodMatcher

Add a negated child matcher.

----------------

opCodes

fun opCodes(opCodes: OpCodesMatcher): MethodMatcher

This method uses opcodes matcher

----------------

@JvmOverloads

fun opCodes(opCodes: Collection<Int>, matchType: OpCodeMatchType = OpCodeMatchType.Contains, opCodeSize: IntRange? = null): MethodMatcher

This method uses consecutive OP instructions.

----------------

opNames

@JvmOverloads

fun opNames(opNames: Collection<String>, matchType: OpCodeMatchType = OpCodeMatchType.Contains, opCodeSize: IntRange? = null): MethodMatcher

This method uses consecutive smali instructions.

----------------

paramCount

fun paramCount(count: Int): MethodMatcher

The method parameter count.

----------------

fun paramCount(range: IntRange): MethodMatcher

fun paramCount(min: Int = 0, max: Int = Int.MAX_VALUE): MethodMatcher

The method parameter count range.

----------------

params

fun params(init: ParametersMatcher.() -> Unit): MethodMatcher

fun params(params: ParametersMatcher): MethodMatcher

The method parameter types matcher.

----------------

paramTypes

fun paramTypes(): MethodMatcher

empty parameters overload.

----------------

fun paramTypes(vararg paramTypes: Class<*>?): MethodMatcher

The method parameter types class matcher. If set to null, it means matching any parameter type. The list implies the number of parameters.

fun paramTypes(vararg paramTypes: String?): MethodMatcher

fun paramTypes(paramTypes: Collection<String?>): MethodMatcher

The method parameter types fully qualified name. If set to null, it means matching any parameter type. The list implies the number of parameters.

protoShorty

fun protoShorty(shorty: String): MethodMatcher

returnType

fun returnType(clazz: Class<*>): MethodMatcher

The method return type.

----------------

fun returnType(init: ClassMatcher.() -> Unit): MethodMatcher

fun returnType(type: ClassMatcher): MethodMatcher

The method return type matcher.

----------------

@JvmOverloads

fun returnType(typeName: String, matchType: StringMatchType = StringMatchType.Equals, ignoreCase: Boolean = false): MethodMatcher

The method return type fully qualified name.

----------------

usingEqStrings

fun usingEqStrings(vararg usingStrings: String): MethodMatcher

fun usingEqStrings(usingStrings: Collection<String>): MethodMatcher

Using strings matcher(fuzzy match).

----------------

usingFields

fun usingFields(init: UsingFieldMatcherList.() -> Unit): MethodMatcher

fun usingFields(usingFields: Collection<UsingFieldMatcher>): MethodMatcher

Using fields matcher.

----------------

usingNumbers

fun usingNumbers(vararg usingNumbers: Number): MethodMatcher

fun usingNumbers(usingNumbers: Collection<Number>): MethodMatcher

Match numbers using the integer/floating semantics described in usingNumbers.

----------------

fun usingNumbers(init: NumberEncodeValueMatcherList.() -> Unit): MethodMatcher

fun usingNumbers(usingNumbers: NumberEncodeValueMatcherList): MethodMatcher

Using numbers matcher.

----------------

usingStrings

fun usingStrings(vararg usingStrings: String): MethodMatcher

Using strings matcher. default match type is contains, if you need to match exactly, please use usingStrings or addUsingString overloaded function for each string.

fun usingStrings(init: StringMatcherList.() -> Unit): MethodMatcher

fun usingStrings(usingStrings: StringMatcherList): MethodMatcher

@JvmOverloads

fun usingStrings(usingStrings: Collection<String>, matchType: StringMatchType = StringMatchType.Contains, ignoreCase: Boolean = false): MethodMatcher

Using strings matcher.

----------------