fix: app no name youtube src main

Author: vuong2023

src/main/kotlin/app/revanced/extensions/Extensions.kt

@@ -0,0 +1,94 @@
+package app.revanced.extensions
+
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
+import app.revanced.patcher.extensions.MethodFingerprintExtensions.name
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.patch.PatchException
+import app.revanced.patcher.util.proxy.mutableTypes.MutableClass
+import app.revanced.patcher.util.proxy.mutableTypes.MutableField
+import app.revanced.patcher.util.proxy.mutableTypes.MutableMethod
+import app.revanced.patcher.util.smali.toInstruction
+import app.revanced.util.integrations.Constants.PATCHES_PATH
+import com.android.tools.smali.dexlib2.builder.MutableMethodImplementation
+import com.android.tools.smali.dexlib2.iface.Method
+import com.android.tools.smali.dexlib2.util.MethodUtil
+import org.w3c.dom.Node
+
+internal fun MutableMethodImplementation.injectHideCall(
+    index: Int,
+    register: Int,
+    patches: String,
+    method: String
+) {
+    this.addInstruction(
+        index,
+        "invoke-static { v$register }, $PATCHES_PATH/$patches;->$method(Landroid/view/View;)V".toInstruction()
+    )
+}
+
+/**
+ * Return [PatchException] from a [MethodFingerprint].
+ *
+ * @return The [PatchException] for the [MethodFingerprint].
+ */
+val MethodFingerprint.exception
+    get() = PatchException("Failed to resolve $name")
+
+/**
+ * Find the [MutableMethod] from a given [Method] in a [MutableClass].
+ *
+ * @param method The [Method] to find.
+ * @return The [MutableMethod].
+ */
+fun MutableClass.findMutableMethodOf(method: Method) = this.methods.first {
+    MethodUtil.methodSignaturesMatch(it, method)
+}
+
+/**
+ * apply a transform to all methods of the class
+ *
+ * @param transform the transformation function. original method goes in, transformed method goes out
+ */
+fun MutableClass.transformMethods(transform: MutableMethod.() -> MutableMethod) {
+    val transformedMethods = methods.map { it.transform() }
+    methods.clear()
+    methods.addAll(transformedMethods)
+}
+
+/**
+ * apply a transform to all fields of the class
+ *
+ * @param transform the transformation function. original field goes in, transformed field goes out
+ */
+fun MutableClass.transformFields(transform: MutableField.() -> MutableField) {
+    val transformedFields = fields.map { it.transform() }
+    fields.clear()
+    fields.addAll(transformedFields)
+}
+
+internal fun Node.doRecursively(action: (Node) -> Unit) {
+    action(this)
+    for (i in 0 until this.childNodes.length) this.childNodes.item(i).doRecursively(action)
+}
+
+internal fun String.startsWithAny(vararg prefixes: String): Boolean {
+    for (prefix in prefixes)
+        if (this.startsWith(prefix))
+            return true
+
+    return false
+}
+
+/**
+ * traverse the class hierarchy starting from the given root class
+ *
+ * @param targetClass the class to start traversing the class hierarchy from
+ * @param callback function that is called for every class in the hierarchy
+ */
+fun BytecodeContext.traverseClassHierarchy(targetClass: MutableClass, callback: MutableClass.() -> Unit) {
+    callback(targetClass)
+    this.findClass(targetClass.superclass ?: return)?.mutableClass?.let {
+        traverseClassHierarchy(it, callback)
+    }
+}

src/main/kotlin/app/revanced/meta/JsonGenerator.kt

@@ -0,0 +1,67 @@
+package app.revanced.meta
+
+import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
+import app.revanced.patcher.extensions.PatchExtensions.dependencies
+import app.revanced.patcher.extensions.PatchExtensions.description
+import app.revanced.patcher.extensions.PatchExtensions.include
+import app.revanced.patcher.extensions.PatchExtensions.options
+import app.revanced.patcher.extensions.PatchExtensions.patchName
+import app.revanced.patcher.patch.PatchOption
+import com.google.gson.GsonBuilder
+import java.io.File
+
+internal class JsonGenerator : PatchesFileGenerator {
+    override fun generate(bundle: PatchBundlePatches) {
+        val patches = bundle.map {
+            JsonPatch(
+                it.patchName,
+                it.description ?: "This patch has no description.",
+                !it.include,
+                it.options?.map { option ->
+                    JsonPatch.Option(
+                        option.key,
+                        option.title,
+                        option.description,
+                        option.required,
+                        option.let { listOption ->
+                            if (listOption is PatchOption.ListOption<*>) {
+                                listOption.options.toMutableList().toTypedArray()
+                            } else null
+                        }
+                    )
+                }?.toTypedArray() ?: emptyArray(),
+                it.dependencies?.map { dep ->
+                    dep.java.patchName
+                }?.toTypedArray() ?: emptyArray(),
+                it.compatiblePackages?.map { pkg ->
+                    JsonPatch.CompatiblePackage(pkg.name, pkg.versions)
+                }?.toTypedArray() ?: emptyArray()
+            )
+        }
+
+        val json = File("patches.json")
+        json.writeText(GsonBuilder().serializeNulls().create().toJson(patches))
+    }
+
+    private class JsonPatch(
+        val name: String,
+        val description: String,
+        val excluded: Boolean,
+        val options: Array<Option>,
+        val dependencies: Array<String>,
+        val compatiblePackages: Array<CompatiblePackage>,
+    ) {
+        class CompatiblePackage(
+            val name: String,
+            val versions: Array<String>,
+        )
+
+        class Option(
+            val key: String,
+            val title: String,
+            val description: String,
+            val required: Boolean,
+            val choices: Array<*>?,
+        )
+    }
+}

src/main/kotlin/app/revanced/meta/PatchesFileGenerator.kt

@@ -0,0 +1,26 @@
+package app.revanced.meta
+
+import app.revanced.patcher.PatchBundleLoader
+import app.revanced.patcher.patch.PatchClass
+import java.io.File
+
+internal typealias PatchBundlePatches = List<PatchClass>
+
+internal interface PatchesFileGenerator {
+    fun generate(bundle: PatchBundlePatches)
+
+    private companion object {
+        @JvmStatic
+        fun main(args: Array<String>) = PatchBundleLoader.Jar(
+            File("build/libs/").listFiles { it -> it.name.endsWith(".jar") }!!.first()
+        ).also { loader ->
+            if (loader.isEmpty()) throw IllegalStateException("No patches found")
+        }.let { bundle ->
+            arrayOf(JsonGenerator(), ReadmeGenerator()).forEach { generator ->
+                generator.generate(
+                    bundle
+                )
+            }
+        }
+    }
+}

src/main/kotlin/app/revanced/meta/ReadmeGenerator.kt

@@ -0,0 +1,84 @@
+package app.revanced.meta
+
+import app.revanced.patcher.data.Context
+import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
+import app.revanced.patcher.extensions.PatchExtensions.description
+import app.revanced.patcher.extensions.PatchExtensions.patchName
+import app.revanced.patcher.patch.Patch
+import com.unascribed.flexver.FlexVerComparator
+import java.io.File
+
+internal class ReadmeGenerator : PatchesFileGenerator {
+    private companion object {
+        private const val TABLE_HEADER =
+            "| \uD83D\uDC8A Patch | \uD83D\uDCDC Description | \uD83C\uDFF9 Target Version |\n" +
+                    "|:--------:|:--------------:|:-----------------:|"
+    }
+
+    override fun generate(bundle: PatchBundlePatches) {
+        val output = StringBuilder()
+
+        mutableMapOf<String, MutableList<Class<out Patch<Context<*>>>>>()
+            .apply {
+                for (patch in bundle) {
+                    patch.compatiblePackages?.forEach { pkg ->
+                        if (!contains(pkg.name)) put(pkg.name, mutableListOf())
+                        this[pkg.name]!!.add(patch)
+                    }
+                }
+            }
+            .entries
+            .sortedByDescending { it.value.size }
+            .forEach { (`package`, patches) ->
+                val supportVersions = buildMap {
+                    patches.forEach { patch ->
+                        patch.compatiblePackages?.single { compatiblePackage -> compatiblePackage.name == `package` }?.versions?.let {
+                            it.forEach { version -> merge(version, 1, Integer::sum) }
+                        }
+                    }
+                }
+
+                val minVersion = supportVersions.let { commonMap ->
+                    commonMap.maxByOrNull { it.value }?.value?.let {
+                        commonMap.entries.filter { supported -> supported.value == it }
+                            .minOfWith(FlexVerComparator::compare, Map.Entry<String, Int>::key)
+                    } ?: "all"
+                }
+                val maxVersion = supportVersions.let { commonMap ->
+                    commonMap.maxByOrNull { it.value }?.value?.let {
+                        commonMap.entries.filter { supported -> supported.value == it }
+                            .maxOfWith(FlexVerComparator::compare, Map.Entry<String, Int>::key)
+                    } ?: "all"
+                }
+
+                output.apply {
+                    appendLine("### [\uD83D\uDCE6 `${`package`}`](https://play.google.com/store/apps/details?id=${`package`})")
+                    appendLine("<details>\n")
+                    appendLine(TABLE_HEADER)
+                    patches.forEach { patch ->
+                        val supportedVersion =
+                            if (
+                                patch.compatiblePackages?.single { it.name == `package` }?.versions?.isNotEmpty() == true
+                            ) {
+                                if (minVersion == maxVersion)
+                                    maxVersion
+                                else
+                                    "$minVersion ~ $maxVersion"
+                            } else
+                                "all"
+
+                        appendLine(
+                            "| `${patch.patchName.lowercase().replace(" ", "-")}` " +
+                                    "| ${patch.description} " +
+                                    "| $supportedVersion |"
+                        )
+                    }
+                    appendLine("</details>\n")
+                }
+            }
+
+        StringBuilder(File("README-template.md").readText())
+            .replace(Regex("\\{\\{\\s?table\\s?}}"), output.toString())
+            .let(File("README.md")::writeText)
+    }
+}

src/main/kotlin/app/revanced/patches/music/ads/music/patch/MusicAdsPatch.kt

@@ -0,0 +1,43 @@
+package app.revanced.patches.music.ads.music.patch
+
+import app.revanced.patcher.annotation.Description
+import app.revanced.patcher.annotation.Name
+
+import app.revanced.patcher.data.BytecodeContext
+
+import app.revanced.patcher.patch.annotations.DependsOn
+import app.revanced.patcher.patch.annotations.Patch
+import app.revanced.patches.music.utils.annotations.MusicCompatibility
+import app.revanced.patches.music.utils.litho.patch.LithoFilterPatch
+import app.revanced.patches.music.utils.settings.resource.patch.SettingsPatch
+import app.revanced.patches.shared.patch.ads.AbstractAdsPatch
+import app.revanced.util.enum.CategoryType
+import app.revanced.util.integrations.Constants.MUSIC_ADS_PATH
+
+@Patch
+@Name("Hide music ads")
+@Description("Hides ads before playing a music.")
+@DependsOn(
+    [
+        LithoFilterPatch::class,
+        SettingsPatch::class
+    ]
+)
+@MusicCompatibility
+
+class MusicAdsPatch : AbstractAdsPatch(
+    "$MUSIC_ADS_PATH/HideMusicAdsPatch;->hideMusicAds()Z"
+) {
+    override fun execute(context: BytecodeContext) {
+        super.execute(context)
+
+        SettingsPatch.addMusicPreference(CategoryType.ADS, "revanced_hide_music_ads", "true")
+
+        LithoFilterPatch.addFilter(FILTER_CLASS_DESCRIPTOR)
+    }
+
+    private companion object {
+        private const val FILTER_CLASS_DESCRIPTOR =
+            "$MUSIC_ADS_PATH/AdsFilter;"
+    }
+}

src/main/kotlin/app/revanced/patches/music/buttoncontainer/downloadbuttonhook/patch/DownloadButtonHookPatch.kt

@@ -0,0 +1,43 @@
+package app.revanced.patches.music.buttoncontainer.downloadbuttonhook.patch
+
+import app.revanced.patcher.annotation.Description
+import app.revanced.patcher.annotation.Name
+import app.revanced.patcher.data.BytecodeContext
+import app.revanced.patcher.patch.BytecodePatch
+import app.revanced.patcher.patch.annotations.DependsOn
+import app.revanced.patcher.patch.annotations.Patch
+import app.revanced.patches.music.utils.annotations.MusicCompatibility
+import app.revanced.patches.music.utils.buttoncontainerhook.patch.ButtonContainerHookPatch
+import app.revanced.patches.music.utils.intenthook.patch.IntentHookPatch
+import app.revanced.patches.music.utils.settings.resource.patch.SettingsPatch
+import app.revanced.patches.music.utils.videoid.patch.VideoIdPatch
+import app.revanced.util.enum.CategoryType
+
+@Patch
+@Name("Hook download button")
+@Description("Replaces the offline download button in the button container with an external download button.")
+@DependsOn(
+    [
+        ButtonContainerHookPatch::class,
+        IntentHookPatch::class,
+        SettingsPatch::class,
+        VideoIdPatch::class
+    ]
+)
+@MusicCompatibility
+class DownloadButtonHookPatch : BytecodePatch() {
+    override fun execute(context: BytecodeContext) {
+
+        SettingsPatch.addMusicPreference(
+            CategoryType.BUTTON_CONTAINER,
+            "revanced_hook_button_container_download",
+            "false"
+        )
+        SettingsPatch.addMusicPreferenceWithIntent(
+            CategoryType.BUTTON_CONTAINER,
+            "revanced_external_downloader_package_name",
+            "revanced_hook_button_container_download"
+        )
+
+    }
+}

src/main/kotlin/app/revanced/patches/music/buttoncontainer/label/fingerprints/ButtonContainerLabelFingerprint.kt

@@ -0,0 +1,20 @@
+package app.revanced.patches.music.buttoncontainer.label.fingerprints
+
+import app.revanced.patcher.extensions.or
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import com.android.tools.smali.dexlib2.AccessFlags
+import com.android.tools.smali.dexlib2.Opcode
+
+object ButtonContainerLabelFingerprint : MethodFingerprint(
+    returnType = "V",
+    accessFlags = AccessFlags.PUBLIC or AccessFlags.FINAL,
+    parameters = listOf("L", "L"),
+    opcodes = listOf(
+        Opcode.INVOKE_INTERFACE,
+        Opcode.MOVE_RESULT_OBJECT,
+        Opcode.CHECK_CAST,
+        Opcode.INVOKE_VIRTUAL,
+        Opcode.MOVE_RESULT,
+        Opcode.IF_EQZ,
+    )
+)