Split build.gradle.kts into smaller files

skiko/buildSrc/build.gradle.kts

@@ -4,9 +4,12 @@ plugins {
 
 repositories {
     mavenCentral()
+    gradlePluginPortal()
 }
 
 dependencies {
     implementation(kotlin("stdlib"))
     compileOnly(gradleApi())
+    implementation(kotlin("gradle-plugin", "1.9.21"))
+    implementation("de.undercouch:gradle-download-task:5.4.0")
 }

skiko/buildSrc/src/main/kotlin/SkikoProjectContext.kt

@@ -0,0 +1,103 @@
+import de.undercouch.gradle.tasks.download.Download
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.bundling.Jar
+import java.io.File
+
+class SkikoProjectContext(
+    val project: Project,
+    val skiko: SkikoProperties,
+    val windowsSdkPathProvider: () -> WindowsSdkPaths,
+    val createChecksumsTask: (OS, Arch, Provider<File>) -> TaskProvider<*>
+) {
+
+    val buildType = skiko.buildType
+
+    val windowsSdkPaths: WindowsSdkPaths by lazy {
+        windowsSdkPathProvider()
+    }
+
+    val allJvmRuntimeJars = mutableMapOf<Pair<OS, Arch>, TaskProvider<Jar>>()
+}
+
+/**
+ * Do not call inside tasks.register or tasks.call callback
+ * (tasks' registration during other task's registration is prohibited)
+ */
+fun SkikoProjectContext.registerOrGetSkiaDirProvider(
+    os: OS, arch: Arch, isIosSim: Boolean = false
+): Provider<File> = with(this.project) {
+    val taskNameSuffix = joinToTitleCamelCase(buildType.id, os.idWithSuffix(isIosSim = isIosSim), arch.id)
+    val skiaRelease = skiko.skiaReleaseFor(os, arch, buildType, isIosSim)
+    val downloadSkia = tasks.registerOrGetTask<Download>("downloadSkia$taskNameSuffix") {
+        onlyIf { !dest.exists() }
+        onlyIfModified(true)
+        val skiaUrl = "https://github.com/JetBrains/skia-pack/releases/download/$skiaRelease.zip"
+        inputs.property("skia.url", skiaUrl)
+        src(skiaUrl)
+        dest(skiko.dependenciesDir.resolve("skia/$skiaRelease.zip"))
+    }.map { it.dest.absoluteFile }
+
+    return if (skiko.skiaDir != null) {
+        tasks.registerOrGetTask<DefaultTask>("skiaDir$taskNameSuffix") {
+            // dummy task to simplify usage of the resulting provider (see `else` branch)
+            // if a file provider is not created from a task provider,
+            // then it cannot be used instead of a task in `dependsOn` clauses of other tasks.
+            // e.g. the resulting `skiaDir` could not be used in `dependsOn` of CppCompile configuration
+            enabled = false
+        }.map { skiko.skiaDir!!.absoluteFile }
+    } else {
+        tasks.registerOrGetTask<Copy>("unzipSkia$taskNameSuffix") {
+            dependsOn(downloadSkia)
+            from(downloadSkia.map { zipTree(it) })
+            into(skiko.dependenciesDir.resolve("skia/$skiaRelease"))
+        }.map { it.destinationDir.absoluteFile }
+    }
+}
+
+internal val Project.isInIdea: Boolean
+    get() {
+        return System.getProperty("idea.active")?.toBoolean() == true
+    }
+
+val Project.supportAndroid: Boolean
+    get() = findProperty("skiko.android.enabled") == "true" // || isInIdea
+
+val Project.supportAwt: Boolean
+    get() = findProperty("skiko.awt.enabled") == "true" || isInIdea
+
+val Project.supportAllNative: Boolean
+    get() = findProperty("skiko.native.enabled") == "true" || isInIdea
+
+val Project.supportAllNativeIos: Boolean
+    get() = supportAllNative || findProperty("skiko.native.ios.enabled") == "true" || isInIdea
+
+val Project.supportNativeIosArm64: Boolean
+    get() = supportAllNativeIos || findProperty("skiko.native.ios.arm64.enabled") == "true" || isInIdea
+
+val Project.supportNativeIosSimulatorArm64: Boolean
+    get() = supportAllNativeIos || findProperty("skiko.native.ios.simulatorArm64.enabled") == "true" || isInIdea
+
+val Project.supportNativeIosX64: Boolean
+    get() = supportAllNativeIos || findProperty("skiko.native.ios.x64.enabled") == "true" || isInIdea
+
+val Project.supportAnyNativeIos: Boolean
+    get() = supportAllNativeIos || supportNativeIosArm64 || supportNativeIosSimulatorArm64 || supportNativeIosX64
+
+val Project.supportNativeMac: Boolean
+    get() = supportAllNative || findProperty("skiko.native.mac.enabled") == "true" || isInIdea
+
+val Project.supportNativeLinux: Boolean
+    get() = supportAllNative || findProperty("skiko.native.linux.enabled") == "true" || isInIdea
+
+val Project.supportAnyNative: Boolean
+    get() = supportAllNative || supportAnyNativeIos || supportNativeMac || supportNativeLinux
+
+val Project.supportWasm: Boolean
+    get() = findProperty("skiko.wasm.enabled") == "true" || isInIdea
+
+val Project.supportJs: Boolean
+    get() = findProperty("skiko.js.enabled") == "true" || supportWasm || isInIdea

skiko/buildSrc/src/main/kotlin/tasks/configuration/CommonTasksConfiguration.kt

@@ -0,0 +1,137 @@
+package tasks.configuration
+
+import OS
+import SkiaBuildType
+import org.gradle.api.Project
+import supportAndroid
+import supportWasm
+import java.io.File
+
+fun skiaHeadersDirs(skiaDir: File): List<File> =
+    listOf(
+        skiaDir,
+        skiaDir.resolve("include"),
+        skiaDir.resolve("include/core"),
+        skiaDir.resolve("include/gpu"),
+        skiaDir.resolve("include/effects"),
+        skiaDir.resolve("include/pathops"),
+        skiaDir.resolve("include/utils"),
+        skiaDir.resolve("include/codec"),
+        skiaDir.resolve("include/svg"),
+        skiaDir.resolve("modules/skottie/include"),
+        skiaDir.resolve("modules/skparagraph/include"),
+        skiaDir.resolve("modules/skshaper/include"),
+        skiaDir.resolve("modules/skunicode/include"),
+        skiaDir.resolve("modules/sksg/include"),
+        skiaDir.resolve("modules/svg/include"),
+        skiaDir.resolve("third_party/externals/harfbuzz/src"),
+        skiaDir.resolve("third_party/icu"),
+        skiaDir.resolve("third_party/externals/icu/source/common"),
+    )
+
+fun includeHeadersFlags(headersDirs: List<File>) =
+    headersDirs.map { "-I${it.absolutePath}" }.toTypedArray()
+
+fun skiaPreprocessorFlags(os: OS, buildType: SkiaBuildType): Array<String> {
+    val base = listOf(
+        "-DSK_ALLOW_STATIC_GLOBAL_INITIALIZERS=1",
+        "-DSK_FORCE_DISTANCE_FIELD_TEXT=0",
+        "-DSK_GAMMA_APPLY_TO_A8",
+        "-DSK_GAMMA_SRGB",
+        "-DSK_SCALAR_TO_FLOAT_EXCLUDED",
+        "-DSK_SUPPORT_GPU=1",
+        "-DSK_GANESH",
+        "-DSK_GL",
+        "-DSK_SHAPER_HARFBUZZ_AVAILABLE",
+        "-DSK_UNICODE_AVAILABLE",
+        "-DSK_SUPPORT_OPENCL=0",
+        "-DSK_UNICODE_AVAILABLE",
+        "-DU_DISABLE_RENAMING",
+        "-DSK_USING_THIRD_PARTY_ICU",
+        *buildType.flags
+    )
+
+    val perOs = when (os) {
+        OS.MacOS -> listOf(
+            "-DSK_SHAPER_CORETEXT_AVAILABLE",
+            "-DSK_BUILD_FOR_MAC",
+            "-DSK_METAL"
+        )
+        OS.IOS -> listOf(
+            "-DSK_BUILD_FOR_IOS",
+            "-DSK_SHAPER_CORETEXT_AVAILABLE",
+            "-DSK_METAL"
+        )
+        OS.Windows -> listOf(
+            "-DSK_BUILD_FOR_WIN",
+            "-D_CRT_SECURE_NO_WARNINGS",
+            "-D_HAS_EXCEPTIONS=0",
+            "-DWIN32_LEAN_AND_MEAN",
+            "-DNOMINMAX",
+            "-DSK_GAMMA_APPLY_TO_A8",
+            "-DSK_DIRECT3D"
+        )
+        OS.Linux -> listOf(
+            "-DSK_BUILD_FOR_LINUX",
+            "-D_GLIBCXX_USE_CXX11_ABI=0"
+        )
+        OS.Wasm -> listOf(
+            "-DSKIKO_WASM"
+        )
+        OS.Android -> listOf(
+            "-DSK_BUILD_FOR_ANDROID"
+        )
+        else -> TODO("unsupported $os")
+    }
+
+    return (base + perOs).toTypedArray()
+}
+
+fun Project.configureSignAndPublishDependencies() {
+    if (supportWasm) {
+        tasks.forEach { task ->
+            val name = task.name
+            val publishJs = "publishJsPublicationTo"
+            val publishWasm = "publishSkikoWasmRuntimePublicationTo"
+            val publishWasmPub = "publishWasmJsPublicationTo"
+            val signWasm = "signSkikoWasmRuntimePublication"
+            val signJs = "signJsPublication"
+            val signWasmPub = "signWasmJsPublication"
+
+            when {
+                name.startsWith(publishJs) -> task.dependsOn(signWasm, signWasmPub)
+                name.startsWith(publishWasm) -> task.dependsOn(signJs)
+                name.startsWith(publishWasmPub) -> task.dependsOn(signJs)
+                name.startsWith(signWasmPub) -> task.dependsOn(signWasm)
+            }
+        }
+    }
+    if (supportAndroid) {
+        tasks.forEach { task ->
+            val name = task.name
+            val signAndroid = "signAndroidPublication"
+            val generateMetadata = "generateMetadataFileForAndroidPublication"
+            val publishAndroid = "publishAndroidPublicationTo"
+            val publishX64 = "publishSkikoJvmRuntimeAndroidX64PublicationTo"
+            val publishArm64 = "publishSkikoJvmRuntimeAndroidArm64PublicationTo"
+            val signX64 = "signSkikoJvmRuntimeAndroidX64Publication"
+            val signArm64 = "signSkikoJvmRuntimeAndroidArm64Publication"
+            val skikoAndroidJar = "skikoAndroidJar"
+
+            when {
+                name.startsWith(signAndroid) || name.startsWith(generateMetadata) -> {
+                    task.dependsOn(skikoAndroidJar)
+                }
+                name.startsWith(publishAndroid) -> {
+                    task.dependsOn(signX64, signArm64)
+                }
+                name.startsWith(publishX64) -> {
+                    task.dependsOn(signAndroid, signArm64)
+                }
+                name.startsWith(publishArm64) -> {
+                    task.dependsOn(signX64, signAndroid)
+                }
+            }
+        }
+    }
+}