allow only specific resolutions for custom icons

LisoUseInAIKyrios · LisoUseInAIKyrios · commit ac905284c45a · 2025-10-04T19:23:20.000+04:00
diff --git a/patches/src/main/kotlin/app/revanced/patches/music/layout/branding/CustomBrandingPatch.kt b/patches/src/main/kotlin/app/revanced/patches/music/layout/branding/CustomBrandingPatch.kt
@@ -63,16 +63,15 @@ val customBrandingPatch = baseCustomBrandingPatch(
     ),
     resourceFolder = "custom-branding/music",
     iconResourceFileNames = arrayOf(
-        "adaptiveproduct_youtube_music_2024_q4_background_color_108",
-        "adaptiveproduct_youtube_music_2024_q4_foreground_color_108",
-        "ic_launcher_release",
+        "adaptiveproduct_youtube_music_2024_q4_background_color_108.png",
+        "adaptiveproduct_youtube_music_2024_q4_foreground_color_108.png"
     ),
     monochromeIconFileNames = arrayOf("ic_app_icons_themed_youtube_music.xml"),
     adaptiveIconFileNames = arrayOf(
         "adaptiveproduct_youtube_music_2024_q4_background_color_108.xml",
-        "adaptiveproduct_youtube_music_2024_q4_foreground_color_108.xml",
+        "adaptiveproduct_youtube_music_2024_q4_foreground_color_108.xml"
     ),
-    legacyIconResourceFileNames = arrayOf("ic_launcher_release"),
+    legacyIconResourceFileNames = arrayOf("ic_launcher_release.png"),
 
     block = {
         dependsOn(disableSplashAnimationPatch)
diff --git a/patches/src/main/kotlin/app/revanced/patches/shared/layout/branding/BaseCustomBrandingPatch.kt b/patches/src/main/kotlin/app/revanced/patches/shared/layout/branding/BaseCustomBrandingPatch.kt
@@ -1,5 +1,6 @@
 package app.revanced.patches.shared.layout.branding
 
+import app.revanced.patcher.patch.PatchException
 import app.revanced.patcher.patch.ResourcePatch
 import app.revanced.patcher.patch.ResourcePatchBuilder
 import app.revanced.patcher.patch.ResourcePatchContext
@@ -14,7 +15,7 @@ import java.util.logging.Logger
 
 private const val REVANCED_ICON = "ReVanced*Logo" // Can never be a valid path.
 
-private val mipmapDirectories = arrayOf(
+internal val mipmapDirectories = arrayOf(
     // Target app does not have ldpi icons.
     "mdpi",
     "hdpi",
@@ -63,10 +64,6 @@ internal fun baseCustomBrandingPatch(
     description = "Applies a custom app name and icon. Defaults to \"$defaultAppName\" and the ReVanced logo.",
     use = false,
 ) {
-    fun Array<String>.addPngExtension() = this.map { "$it.png" }.toTypedArray<String>()
-    val iconResourceFileNamesPng = iconResourceFileNames.addPngExtension()
-    val legacyIconResourceFileNamesPng = legacyIconResourceFileNames.addPngExtension()
-
     val appName by stringOption(
         key = "appName",
         default = defaultAppName,
@@ -83,16 +80,13 @@ internal fun baseCustomBrandingPatch(
         description = """
             The icon to apply to the app.
             
-            If a path to a folder is provided, the folder must contain the following folders:
-    
+            If a path to a folder is provided, the folder must contain one or more of the following folders:
             ${formatResourceFileList(mipmapDirectories)}
     
             Each of these folders must contain the following files:
-    
-            ${formatResourceFileList((iconResourceFileNamesPng + legacyIconResourceFileNamesPng))}
+            ${formatResourceFileList((iconResourceFileNames + legacyIconResourceFileNames))}
             
             Optionally, a 'drawable' folder with the monochrome icon files:
-    
             ${formatResourceFileList(monochromeIconFileNames)}
         """.trimIndentMultiline(),
     )
@@ -103,64 +97,71 @@ internal fun baseCustomBrandingPatch(
         val iconPathTrimmed = iconPath!!.trim()
 
         if (iconPathTrimmed == REVANCED_ICON) {
-            val mipmapIconResourceGroups = mipmapDirectories.map { directory ->
-                ResourceGroup(
-                    directory,
-                    *legacyIconResourceFileNamesPng,
-                )
-            }
-
-            // Copy monochrome icons.
+            // Copy adaptive icons.
             copyResources(
                 resourceFolder,
-                ResourceGroup("drawable", *monochromeIconFileNames)
+                ResourceGroup("mipmap-anydpi", *adaptiveIconFileNames)
             )
 
             // Copy legacy icons.
-            mipmapIconResourceGroups.forEach { groupResources ->
+            mipmapDirectories.map { directory ->
+                ResourceGroup(
+                    directory,
+                    *legacyIconResourceFileNames,
+                )
+            }.forEach { groupResources ->
                 copyResources(resourceFolder, groupResources)
             }
 
-            // Copy adaptive icons.
+            // Copy monochrome icons.
             copyResources(
                 resourceFolder,
-                ResourceGroup("mipmap-anydpi", *adaptiveIconFileNames)
+                ResourceGroup("drawable", *monochromeIconFileNames)
             )
         } else {
-            val mipmapIconResourceGroups = mipmapDirectories.map { directory ->
-                ResourceGroup(
-                    directory,
-                    *iconResourceFileNamesPng,
-                )
-            }
-
-            val filePath = File(iconPathTrimmed)
+            val iconPathFile = File(iconPathTrimmed)
             val resourceDirectory = get("res")
+            var replacedResources = false
 
             // Replace mipmap icons.
-            mipmapIconResourceGroups.forEach { groupResources ->
+            mipmapDirectories.map { directory ->
+                ResourceGroup(
+                    directory,
+                    *iconResourceFileNames,
+                )
+            }.forEach { groupResources ->
                 val groupResourceDirectoryName = groupResources.resourceDirectoryName
-                val fromDirectory = filePath.resolve(groupResourceDirectoryName)
+                val fromDirectory = iconPathFile.resolve(groupResourceDirectoryName)
                 val toDirectory = resourceDirectory.resolve(groupResourceDirectoryName)
 
                 groupResources.resources.forEach { iconFileName ->
-                    Files.write(
-                        toDirectory.resolve(iconFileName).toPath(),
-                        fromDirectory.resolve(iconFileName).readBytes(),
-                    )
+                    val replacement = fromDirectory.resolve(iconFileName)
+                    if (replacement.exists()) {
+                        Files.write(
+                            toDirectory.resolve(iconFileName).toPath(),
+                            replacement.readBytes(),
+                        )
+                        replacedResources = true
+                    }
                 }
             }
 
             // Replace monochrome icons if provided.
-            monochromeIconFileNames.forEach { fileName ->
-                val replacementMonochrome = filePath.resolve("drawable").resolve(fileName)
-                if (replacementMonochrome.exists()) {
+            monochromeIconFileNames.forEach { iconFileName ->
+                val resourceType = "drawable"
+                val replacement = iconPathFile.resolve(resourceType).resolve(iconFileName)
+                if (replacement.exists()) {
                     Files.write(
-                        resourceDirectory.resolve("drawable").resolve(fileName).toPath(),
-                        replacementMonochrome.readBytes(),
+                        resourceDirectory.resolve(resourceType).resolve(iconFileName).toPath(),
+                        replacement.readBytes(),
                     )
+                    replacedResources = true
                 }
             }
+
+            if (!replacedResources) {
+                throw PatchException("Could not find any replacement images in patch option path: $iconPathTrimmed")
+            }
         }
 
         // Change the app name.
diff --git a/patches/src/main/kotlin/app/revanced/patches/youtube/layout/branding/CustomBrandingPatch.kt b/patches/src/main/kotlin/app/revanced/patches/youtube/layout/branding/CustomBrandingPatch.kt
@@ -1,12 +1,13 @@
 package app.revanced.patches.youtube.layout.branding
 
 import app.revanced.patches.shared.layout.branding.baseCustomBrandingPatch
+import app.revanced.patches.shared.layout.branding.mipmapDirectories
 import java.nio.file.Files
 
 private const val APP_NAME = "YouTube ReVanced"
 
-private const val ADAPTIVE_BACKGROUND_RESOURCE_FILE_NAME = "adaptiveproduct_youtube_background_color_108.xml"
-private const val ADAPTIVE_FOREGROUND_RESOURCE_FILE_NAME = "adaptiveproduct_youtube_foreground_color_108.xml"
+private const val ADAPTIVE_BACKGROUND_RESOURCE_NAME = "adaptiveproduct_youtube_background_color_108"
+private const val ADAPTIVE_FOREGROUND_RESOURCE_NAME = "adaptiveproduct_youtube_foreground_color_108"
 
 @Suppress("unused")
 val customBrandingPatch = baseCustomBrandingPatch(
@@ -19,22 +20,20 @@ val customBrandingPatch = baseCustomBrandingPatch(
     ),
     resourceFolder = "custom-branding/youtube",
     iconResourceFileNames = arrayOf(
-        "adaptiveproduct_youtube_background_color_108",
-        "adaptiveproduct_youtube_foreground_color_108",
-        "ic_launcher",
-        "ic_launcher_round",
+        "$ADAPTIVE_BACKGROUND_RESOURCE_NAME.png",
+        "$ADAPTIVE_FOREGROUND_RESOURCE_NAME.png",
     ),
     monochromeIconFileNames = arrayOf(
         "adaptive_monochrome_ic_youtube_launcher.xml",
         "ringo2_adaptive_monochrome_ic_youtube_launcher.xml"
     ),
     adaptiveIconFileNames = arrayOf(
-        ADAPTIVE_BACKGROUND_RESOURCE_FILE_NAME,
-        ADAPTIVE_FOREGROUND_RESOURCE_FILE_NAME,
+        "$ADAPTIVE_BACKGROUND_RESOURCE_NAME.xml",
+        "$ADAPTIVE_FOREGROUND_RESOURCE_NAME.xml",
     ),
     legacyIconResourceFileNames = arrayOf(
-        "ic_launcher",
-        // "ic_launcher_round" also exists in 19.34, but was removed in later targets.
+        "ic_launcher.png",
+        // "ic_launcher_round" exists in 19.34, but was removed in later targets.
     ),
 
     block = {
@@ -49,17 +48,35 @@ val customBrandingPatch = baseCustomBrandingPatch(
     },
 
     executeBlock = {
-        val resourceDirectory = get("res/mipmap-anydpi")
+        val resourceDirectory = get("res")
 
         // Copy adaptive icon to secondary adaptive file.
         arrayOf(
-            ADAPTIVE_BACKGROUND_RESOURCE_FILE_NAME to "adaptiveproduct_youtube_2024_q4_background_color_108.xml",
-            ADAPTIVE_FOREGROUND_RESOURCE_FILE_NAME to "adaptiveproduct_youtube_2024_q4_foreground_color_108.xml",
+            ADAPTIVE_BACKGROUND_RESOURCE_NAME to "adaptiveproduct_youtube_2024_q4_background_color_108",
+            ADAPTIVE_FOREGROUND_RESOURCE_NAME to "adaptiveproduct_youtube_2024_q4_foreground_color_108",
         ).forEach { (old, new) ->
-            val oldFile = resourceDirectory.resolve(old)
-            val newFile = resourceDirectory.resolve(new)
+            var resourceType = "mipmap-anydpi"
+            val oldFile = resourceDirectory.resolve("$resourceType/$old.xml")
+            if (oldFile.exists()) {
+                val newFile = resourceDirectory.resolve("$resourceType/$new.xml")
+                Files.write(newFile.toPath(), oldFile.readBytes())
+            }
+        }
+
+        // Copy mipmaps to secondary files.
+        mipmapDirectories.forEach { directory ->
+            val targetDirectory = resourceDirectory.resolve(directory)
 
-            Files.write(newFile.toPath(), oldFile.readBytes())
+            arrayOf(
+                ADAPTIVE_BACKGROUND_RESOURCE_NAME to "adaptiveproduct_youtube_2024_q4_background_color_108",
+                ADAPTIVE_FOREGROUND_RESOURCE_NAME to "adaptiveproduct_youtube_2024_q4_foreground_color_108",
+            ).forEach { (old, new) ->
+                val oldFile = targetDirectory.resolve("$old.png")
+                if (oldFile.exists()) {
+                    val newFile = targetDirectory.resolve("$new.png")
+                    Files.write(newFile.toPath(), oldFile.readBytes())
+                }
+            }
         }
     }
 )
