Register all hierarchical compose resources in android compilation

components/resources/demo/shared/src/androidMain/composeResources/files/platform-text.txt

@@ -0,0 +1 @@
+Android platform

components/resources/demo/shared/src/commonMain/kotlin/org/jetbrains/compose/resources/demo/shared/FileRes.kt

@@ -1,22 +1,11 @@
 package org.jetbrains.compose.resources.demo.shared
 
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedCard
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import components.resources.demo.shared.generated.resources.Res
@@ -59,5 +48,37 @@ fun FileRes(paddingValues: PaddingValues) {
                 Text(bytes.decodeToString())
             """.trimIndent()
         )
+        Text(
+            modifier = Modifier.padding(16.dp),
+            text = "File: 'files/platform-text.txt'",
+            style = MaterialTheme.typography.titleLarge
+        )
+        OutlinedCard(
+            modifier = Modifier.padding(horizontal = 16.dp),
+            shape = RoundedCornerShape(4.dp),
+            colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primaryContainer)
+        ) {
+            var bytes by remember { mutableStateOf(ByteArray(0)) }
+            LaunchedEffect(Unit) {
+                bytes = Res.readBytes("files/platform-text.txt")
+            }
+            Text(
+                modifier = Modifier.padding(8.dp),
+                text = bytes.decodeToString(),
+                color = MaterialTheme.colorScheme.onPrimaryContainer
+            )
+        }
+        Text(
+            modifier = Modifier.padding(16.dp),
+            text = """
+                var bytes by remember { 
+                  mutableStateOf(ByteArray(0))
+                }
+                LaunchedEffect(Unit) {
+                  bytes = Res.readFileBytes("files/platform-text.txt")
+                }
+                Text(bytes.decodeToString())
+            """.trimIndent()
+        )
     }
 }

components/resources/demo/shared/src/desktopMain/composeResources/files/platform-text.txt

@@ -0,0 +1 @@
+Desktop platform

components/resources/demo/shared/src/iosMain/composeResources/files/platform-text.txt

@@ -0,0 +1 @@
+iOS platform

components/resources/demo/shared/src/jsMain/composeResources/files/platform-text.txt

@@ -0,0 +1 @@
+JS platform

components/resources/demo/shared/src/macosMain/composeResources/files/platform-text.txt

@@ -0,0 +1 @@
+macOS platform

components/resources/demo/shared/src/wasmJsMain/composeResources/files/platform-text.txt

@@ -0,0 +1 @@
+WasmJS platform

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/ResourcesGenerator.kt

@@ -1,46 +1,113 @@
 package org.jetbrains.compose.resources
 
+import com.android.build.api.variant.AndroidComponentsExtension
+import com.android.build.gradle.BaseExtension
+import com.android.build.gradle.internal.tasks.ProcessJavaResTask
+import org.gradle.api.DefaultTask
 import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
-import org.gradle.api.tasks.SourceSet
+import org.gradle.api.tasks.*
 import org.jetbrains.compose.ComposePlugin
 import org.jetbrains.compose.desktop.application.internal.ComposeProperties
 import org.jetbrains.compose.internal.KOTLIN_JVM_PLUGIN_ID
 import org.jetbrains.compose.internal.KOTLIN_MPP_PLUGIN_ID
+import org.jetbrains.compose.internal.utils.*
+import org.jetbrains.compose.internal.utils.dependsOn
+import org.jetbrains.compose.internal.utils.registerTask
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
+import org.jetbrains.kotlin.gradle.plugin.sources.android.androidSourceSetInfoOrNull
+import org.jetbrains.kotlin.gradle.utils.ObservableSet
 import java.io.File
+import javax.inject.Inject
 
 internal const val COMPOSE_RESOURCES_DIR = "composeResources"
-private const val RES_GEN_DIR = "generated/compose/resourceGenerator"
+internal const val RES_GEN_DIR = "generated/compose/resourceGenerator"
 private val androidPluginIds = listOf(
     "com.android.application",
     "com.android.library"
 )
 
 internal fun Project.configureComposeResources() {
     plugins.withId(KOTLIN_MPP_PLUGIN_ID) {
-        configureComposeResources(KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME)
+        val kotlinExtension = project.extensions.getByType(KotlinMultiplatformExtension::class.java)
+        configureComposeResources(kotlinExtension, KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME)
+
+        //when applied AGP then configure android resources
+        androidPluginIds.forEach { pluginId ->
+            plugins.withId(pluginId) {
+                val androidExtension = project.extensions.getByType(BaseExtension::class.java)
+                configureAndroidComposeResources(kotlinExtension, androidExtension)
+            }
+        }
     }
     plugins.withId(KOTLIN_JVM_PLUGIN_ID) {
-        configureComposeResources(SourceSet.MAIN_SOURCE_SET_NAME)
+        val kotlinExtension = project.extensions.getByType(KotlinProjectExtension::class.java)
+        configureComposeResources(kotlinExtension, SourceSet.MAIN_SOURCE_SET_NAME)
     }
 }
 
-private fun Project.configureComposeResources(commonSourceSetName: String) {
-    val kotlinExtension = project.extensions.getByType(KotlinProjectExtension::class.java)
+private fun Project.configureComposeResources(kotlinExtension: KotlinProjectExtension, commonSourceSetName: String) {
     kotlinExtension.sourceSets.all { sourceSet ->
         val sourceSetName = sourceSet.name
         val composeResourcesPath = project.projectDir.resolve("src/$sourceSetName/$COMPOSE_RESOURCES_DIR")
+
+        //To compose resources will be packed to a final artefact we need to mark them as resources
+        //sourceSet.resources works for all targets except ANDROID!
         sourceSet.resources.srcDirs(composeResourcesPath)
+
         if (sourceSetName == commonSourceSetName) {
             configureResourceGenerator(composeResourcesPath, sourceSet)
         }
     }
 }
 
+@OptIn(ExperimentalKotlinGradlePluginApi::class)
+private fun Project.configureAndroidComposeResources(
+    kotlinExtension: KotlinMultiplatformExtension,
+    androidExtension: BaseExtension
+) {
+    //mark all composeResources as Android resources
+    kotlinExtension.targets.matching { it is KotlinAndroidTarget }.all { androidTarget ->
+        androidTarget.compilations.all { compilation: KotlinCompilation<*> ->
+            compilation.defaultSourceSet.androidSourceSetInfoOrNull?.let { kotlinAndroidSourceSet ->
+                androidExtension.sourceSets
+                    .matching { it.name == kotlinAndroidSourceSet.androidSourceSetName }
+                    .all { androidSourceSet ->
+                        (compilation.allKotlinSourceSets as ObservableSet<KotlinSourceSet>).forAll { kotlinSourceSet ->
+                            androidSourceSet.resources.srcDir(
+                                projectDir.resolve("src/${kotlinSourceSet.name}/$COMPOSE_RESOURCES_DIR")
+                            )
+                        }
+                    }
+            }
+        }
+    }
+
+    //copy fonts from the compose resources dir to android assets
+    val androidComponents = project.extensions.findByType(AndroidComponentsExtension::class.java) ?: return
+    val commonResourcesDir = projectDir.resolve("src/${KotlinSourceSet.COMMON_MAIN_SOURCE_SET_NAME}/$COMPOSE_RESOURCES_DIR")
+    androidComponents.onVariants { variant ->
+        val copyFonts = registerTask<CopyAndroidFontsToAssetsTask>(
+            "copy${variant.name.uppercaseFirstChar()}FontsToAndroidAssets"
+        ) {
+            from.set(commonResourcesDir)
+        }
+        variant.sources?.assets?.addGeneratedSourceDirectory(
+            taskProvider = copyFonts,
+            wiredWith = CopyAndroidFontsToAssetsTask::outputDirectory
+        )
+    }
+}
+
 private fun Project.configureResourceGenerator(commonComposeResourcesDir: File, commonSourceSet: KotlinSourceSet) {
-    val commonComposeResources = provider { commonComposeResourcesDir }
     val packageName = provider {
         buildString {
             val group = project.group.toString().lowercase().asUnderscoredIdentifier()
@@ -73,7 +140,7 @@ private fun Project.configureResourceGenerator(commonComposeResourcesDir: File,
     ) {
         it.packageName.set(packageName)
         it.shouldGenerateResClass.set(shouldGenerateResClass)
-        it.resDir.set(commonComposeResources)
+        it.resDir.set(commonComposeResourcesDir)
         it.codeDir.set(buildDir("$RES_GEN_DIR/kotlin"))
     }
 
@@ -86,15 +153,26 @@ private fun Project.configureResourceGenerator(commonComposeResourcesDir: File,
             it.dependsOn(genTask)
         }
     }
+}
 
-    //when applied AGP then configure android resources
-    androidPluginIds.forEach { pluginId ->
-        plugins.withId(pluginId) {
-            configureAndroidResources(
-                commonComposeResources,
-                buildDir("$RES_GEN_DIR/androidFonts").map { it.asFile },
-                shouldGenerateResClass
-            )
+//Copy task doesn't work with 'variant.sources?.assets?.addGeneratedSourceDirectory' API
+internal abstract class CopyAndroidFontsToAssetsTask : DefaultTask() {
+    @get:Inject
+    abstract val fileSystem: FileSystemOperations
+
+    @get:Input
+    abstract val from: Property<File>
+
+    @get:OutputDirectory
+    abstract val outputDirectory: DirectoryProperty
+
+    @TaskAction
+    fun action() {
+        fileSystem.copy {
+            it.includeEmptyDirs = false
+            it.from(from)
+            it.include("**/font*/*")
+            it.into(outputDirectory)
         }
     }
-}
+}