DexKit Documentation

ProtoShorty is a compact string representation of a method's return and parameter types. The first character represents the return type, and the subsequent characters represent the parameter types.

Note: In shorthand, all reference types (classes, interfaces, arrays, etc.) are represented by the single character L to maintain compactness.

Type Character Mapping

Usage Examples

The appTag is the core identity for DexKitCacheBridge. It controls three main scopes:

1. Bridge Reuse: DexKitCacheBridge.create(appTag, ...) reuses the current pooled wrapper if it is reachable and matches the appTag.
2. Cache Namespace: All query cache entries are stored under a namespace derived from the appTag.
3. Cleanup Scope: clearCache(appTag) only removes entries belonging to that specific tag.

Best Practices:

• Use stable identifiers like the host package name or version (e.g., "com.example:1.0.0").
• If using version numbers in the tag, host upgrades/downgrades will automatically switch cache namespaces, preventing stale cache usage.
• Multi-process Note: Bridge reuse is process-local. To share cache data across processes, your Cache implementation must support cross-process visibility (e.g., MMKV in multi-process mode or a ContentProvider).

ClassMatcher, FieldMatcher, and MethodMatcher support composite conditions to create complex logical queries. Inside a matcher {} block, regular conditions are implicitly joined with AND.

Supported composite operators:

• allOf { ... }: All child conditions must match.
• anyOf { ... }: At least one child condition must match.
• noneOf { ... }: All child conditions must not match.
• not { ... }: Negates a single condition.

Kotlin DSL Example:

val method = bridge.findMethod {
    matcher {
        declaredClass("org.example.PlayActivity")
        anyOf {
            match { name = "onCreate" }
            match { usingStrings("onClick") }
        }
        not { usingStrings("rollDice: ") }
    }
}

Java Chaining API Example: If you cannot use Kotlin DSL closures, use the chaining API:

MethodMatcher matcher = MethodMatcher.create()
        .declaredClass("org.example.PlayActivity")
        .anyOf(
                MethodMatcher.create().name("onCreate"),
                MethodMatcher.create().usingStrings(List.of("onClick"), StringMatchType.Contains, false)
        )
        .not(MethodMatcher.create().usingStrings(List.of("rollDice: "), StringMatchType.Contains, false));

DexKit matchers and result objects use raw DEX access_flags in their modifiers fields. While most users can use standard java.lang.reflect.Modifier constants, you should use DexAccessFlags when you need to match compiler-generated flags or DEX-specific semantics that are not covered by the standard Java Modifier subset.

Key distinctions:

• Modifier constants are a numeric subset of DEX access flags.
• DexAccessFlags is required for flags like BRIDGE or SYNTHETIC.
• Synchronization matching: To match an ordinary source-level synchronized method, use DexAccessFlags.DECLARED_SYNCHRONIZED (0x20000). Note that DexAccessFlags.SYNCHRONIZED (0x20) is only valid for native methods in DEX.
• The two models are not equivalent; DexAccessFlags provides access to the full DEX specification.

// Kotlin usage
modifiers = Modifier.PUBLIC or DexAccessFlags.BRIDGE or DexAccessFlags.SYNTHETIC

// Java usage
.modifiers(Modifier.PUBLIC | DexAccessFlags.BRIDGE | DexAccessFlags.SYNTHETIC)