Real Patch Examples

// Fingerprints.kt
object LoadVideoAdsFingerprint : Fingerprint(
    strings = listOf(
        "TriggerBundle doesn't have the required metadata specified by the trigger ",
        "Ping migration no associated ping bindings for activated trigger: ",
    )
)

// VideoAdsPatch.kt
val videoAdsPatch = bytecodePatch(name = "Video ads", description = "Removes video ads.") {
    dependsOn(sharedExtensionPatch, settingsPatch)
    compatibleWith(COMPATIBILITY_YOUTUBE)
    execute {
        PreferenceScreen.ADS.addPreferences(SwitchPreference("morphe_hide_video_ads"))
        LoadVideoAdsFingerprint.method.addInstructionsWithLabels(0, """
            invoke-static { }, $EXTENSION->hideVideoAds()Z
            move-result v0
            if-eqz v0, :show
            return-void
            :show
            nop
        """)
    }
}

// Filter list items by calling extension method
fingerprint.let {
    it.method.apply {
        val index = it.instructionMatches.last().index
        val register = getInstruction<TwoRegisterInstruction>(index).registerA
        addInstructions(index, """
            invoke-static { v$register }, $EXT->filter(Ljava/util/List;)Ljava/util/List;
            move-result-object v$register
        """)
    }
}

// Override all return statements in a method
fingerprint.method.apply {
    findInstructionIndicesReversedOrThrow(Opcode.RETURN).forEach { index ->
        val register = getInstruction<OneRegisterInstruction>(index).registerA
        addInstructionsAtControlFlowLabel(index, """
            invoke-static { v$register }, $EXT->isAllowed(Z)Z
            move-result v$register
        """)
    }
}

// Or simply force return value
SomeFingerprint.method.returnEarly(true)

// Find class via toString fingerprint, then find constructor in that class
object AdPostSectionToStringFingerprint : Fingerprint(
    name = "toString",
    returnType = "Ljava/lang/String;",
    filters = listOf(string("AdPostSection(linkId="))
)

object AdPostSectionConstructorFingerprint : Fingerprint(
    classFingerprint = AdPostSectionToStringFingerprint,
    name = "<init>",
    returnType = "V",
    filters = listOf(string("sections"))
)

execute {
    val field = SomeToStringFingerprint.method.findFieldFromToString(", fieldName=")

    val dynamicFingerprint = Fingerprint(
        definingClass = SomeToStringFingerprint.originalClassDef.type,
        name = "<init>",
        returnType = "V",
        filters = listOf(fieldAccess(opcode = Opcode.IPUT_BOOLEAN, reference = field))
    )
    dynamicFingerprint.method.apply { /* modify */ }
}

val stringFilter = string("old string")
Fingerprint(filters = listOf(stringFilter)).matchAll().forEach { match ->
    match.method.apply {
        findInstructionIndicesReversedOrThrow(stringFilter).forEach { index ->
            val register = getInstruction<OneRegisterInstruction>(index).registerA
            replaceInstruction(index, "const-string v$register, \"new string\"")
        }
    }
}

val newMethod = ImmutableMethod(
    classDef.type, "getPaidLicense", null, returnType,
    AccessFlags.STATIC.value, null, null,
    MutableMethodImplementation(7)
).toMutable().apply {
    addInstructions(0, """
        new-instance v0, ${LicenseFingerprint.classDef.type}
        // construct license object with fields
        return-object v0
    """)
}
classDef.methods.add(newMethod)
originalMethod.addInstructions(0, """
    invoke-static {}, $newMethod
    move-result-object v0
    return-object v0
""")

classDefBy("Lcom/google/firebase/crashlytics/internal/common/CommonUtils;")
    .methods.first { it.name == "isRooted" }
    .toMutable()
    .addInstructions(0, "const/4 v0, 0x0\nreturn v0")

classDefBy("Lokhttp3/CertificatePinner;")
    .methods.filter { it.name == "check" }
    .forEach { it.toMutable().addInstructions(0, "return-void") }

ProcessLicenseResponseFingerprint.method.addInstruction(0, "const/4 p1, 0x0")
ValidateLicenseResponseFingerprint.method.returnEarly()

// Navigate to the mutable method called at a matched instruction
val calledMethod = MyFingerprint.instructionMatches[0].getMethodCalled()
calledMethod.returnEarly(true)

val mountOnlyPatch = bytecodePatch(name = "Mount Feature") {
    availability { installer, _ ->
        if (installer == InstallerType.MOUNT) PatchAvailability.ENABLED
        else PatchAvailability.UNAVAILABLE
    }
    category("Misc")
    execute { /* … */ }
}

patches/src/main/kotlin/app/morphe/patches/
├── shared/              # Shared across all apps
│   ├── Fingerprints.kt
│   └── misc/
│       ├── debugging/
│       ├── gms/         # GmsCore/MicroG support
│       ├── settings/    # Settings framework + preferences
│       ├── extension/   # Shared extension loading
│       └── ...
├── youtube/
│   ├── shared/Constants.kt   # COMPATIBILITY_YOUTUBE
│   ├── ad/video/             # Video ads
│   ├── ad/general/           # General ads
│   ├── layout/               # UI modifications
│   ├── misc/                 # Background playback, spoofing, etc.
│   ├── video/                # Playback speed, quality, etc.
│   └── interaction/          # Seekbar, downloads, swipe controls
├── music/
│   ├── shared/Constants.kt   # COMPATIBILITY_YOUTUBE_MUSIC
│   └── ...
└── reddit/
    ├── shared/Constants.kt   # COMPATIBILITY_REDDIT
    └── ...

extensions/
├── youtube/src/main/java/    # YouTube extension code (.mpe output)
├── music/src/main/java/      # Music extension code
├── reddit/src/main/java/     # Reddit extension code
├── shared/src/main/java/     # Shared extension code
└── shared-youtube/           # Shared between YT and YT Music