Wizard: add configuration for Android MPP target

2020-02-20 21:30:59 +03:00
parent 3eca687611
commit 7e22572324
21 changed files with 347 additions and 165 deletions
@@ -1,6 +1,6 @@
 plugins {
    id 'com.android.application'
-    id 'kotlin-android'
+    id 'org.jetbrains.kotlin.android' version '1.3.61'
    id 'kotlin-android-extensions'
 }
 group = 'testGroupId'
@@ -13,8 +13,8 @@ repositories {
    mavenCentral()
 }
 dependencies {
-    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.core:core-ktx:1.1.0'
+    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk7'
 }
@@ -1,6 +1,6 @@
 plugins {
    id("com.android.application")
-    id("kotlin-android")
+    kotlin("android") version "1.3.61"
    id("kotlin-android-extensions")
 }
 group = "testGroupId"
@@ -13,8 +13,8 @@ repositories {
    mavenCentral()
 }
 dependencies {
-    implementation("androidx.appcompat:appcompat:1.1.0")
    implementation("androidx.core:core-ktx:1.1.0")
+    implementation("androidx.appcompat:appcompat:1.1.0")
    implementation("androidx.constraintlayout:constraintlayout:1.1.3")
    implementation(kotlin("stdlib-jdk7"))
 }
@@ -1,14 +1,3 @@
-buildscript {
-    repositories {
-        gradlePluginPortal()
-        google()
-        jcenter()
-    }
-    dependencies {
-        classpath 'com.android.tools.build:gradle:3.2.1'
-        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.61'
-    }
-}
 group = 'testGroupId'
 version = '1.0-SNAPSHOT'

@@ -1,14 +1,3 @@
-buildscript {
-    repositories {
-        gradlePluginPortal()
-        google()
-        jcenter()
-    }
-    dependencies {
-        classpath("com.android.tools.build:gradle:3.2.1")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.61")
-    }
-}
 group = "testGroupId"
 version = "1.0-SNAPSHOT"

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="${package.asCodePackage()}"/>
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.tools.projectWizard
+
+import org.jetbrains.kotlin.tools.projectWizard.settings.version.Version
+
+object Versions {
+    object GradlePlugins {
+        val ANDROID = version("3.5.2")
+    }
+}
+
+private fun version(version: String) = Version.fromString(version)
@@ -43,10 +43,9 @@ data class KotlinBuildSystemPluginIR(

    override fun BuildFilePrinter.render() = when (this) {
        is GradlePrinter -> {
-            when {
-                type == Type.android -> call("id") { +"kotlin-android".quotified }
-                dsl == GradlePrinter.GradleDsl.KOTLIN -> call("kotlin") { +type.toString().quotified }
-                else -> call("id") { +"org.jetbrains.kotlin.$type".quotified }
+            when (dsl) {
+                GradlePrinter.GradleDsl.KOTLIN -> call("kotlin") { +type.toString().quotified }
+                GradlePrinter.GradleDsl.GROOVY -> call("id") { +"org.jetbrains.kotlin.$type".quotified }
            }
            version?.let {
                +" version "
@@ -20,6 +20,9 @@ inline fun <reified I : BuildSystemIR> IrsOwner.irsOfType(): List<I> =
 inline fun <reified I : BuildSystemIR> IrsOwner.irsOfTypeOrNull() =
    irsOfType<I>().takeIf { it.isNotEmpty() }

+inline fun <reified I : BuildSystemIR> List<BuildSystemIR>.irsOfTypeOrNull() =
+    filterIsInstance<I>().takeIf { it.isNotEmpty() }
+

 inline fun <reified T : BuildSystemIR> IrsOwner.firstIrOfType() =
    irs.firstOrNull { ir -> ir is T } as T?
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem
+
+import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.gradle.GradleIR
+import org.jetbrains.kotlin.tools.projectWizard.plugins.printer.GradlePrinter
+import org.jetbrains.kotlin.tools.projectWizard.settings.version.Version
+
+interface PluginManagementIR : GradleIR
+
+data class AndroidResolutionStrategyIR(
+    val androidGradlePluginVersion: Version
+) : PluginManagementIR, FreeIR {
+    override fun GradlePrinter.renderGradle() {
+        sectionCall("resolutionStrategy", needIndent = true) {
+            sectionCall("eachPlugin", needIndent = true) {
+                sectionCall(
+                    "if (requested.id.namespace == ${"com.android".quotified} || requested.id.name == ${"kotlin-android-extensions".quotified})",
+                    needIndent = true
+                ) {
+                    call("useModule", forceBrackets = true) {
+                        when (dsl) {
+                            GradlePrinter.GradleDsl.KOTLIN ->
+                                +"com.android.tools.build:gradle:${androidGradlePluginVersion}".quotified
+                            GradlePrinter.GradleDsl.GROOVY ->
+                                +"com.android.tools.build:gradle:$androidGradlePluginVersion".quotified
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+data class PluginManagementRepositoryIR(val repositoryIR: RepositoryIR) : PluginManagementIR {
+    override fun GradlePrinter.renderGradle() {
+        repositoryIR.render(this)
+    }
+}
@@ -7,12 +7,14 @@ import org.jetbrains.kotlin.tools.projectWizard.settings.JavaPackage
 interface AndroidIR : GradleIR

 //TODO parematrize
-data class AndroidConfigIR(val javaPackage: JavaPackage) : AndroidIR, FreeIR {
+data class AndroidConfigIR(val javaPackage: JavaPackage?) : AndroidIR, FreeIR {
    override fun GradlePrinter.renderGradle() {
        sectionCall("android", needIndent = true) {
            call("compileSdkVersion") { +"29" }; nlIndented() // TODO dehardcode
            sectionCall("defaultConfig", needIndent = true) {
-                assignmentOrCall("applicationId") { +javaPackage.asCodePackage().quotified }; nlIndented()
+                if (javaPackage != null) {
+                    assignmentOrCall("applicationId") { +javaPackage.asCodePackage().quotified }; nlIndented()
+                }
                call("minSdkVersion") { +"24" }; nlIndented()  // TODO dehardcode
                call("targetSdkVersion") { +"29" }; nlIndented() // TODO dehardcode
                assignmentOrCall("versionCode") { +"1" }; nlIndented()
@@ -16,15 +16,19 @@ data class SettingsGradleFileIR(
    override fun withReplacedIrs(irs: List<BuildSystemIR>): SettingsGradleFileIR = copy(irs = irs)

    override fun GradlePrinter.renderGradle() {
-        val repositories = irsOfType<RepositoryIR>()
-        if (repositories.isNotEmpty()) {
+        irsOfTypeOrNull<PluginManagementIR>()?.let { pluginManagementIrs ->
            sectionCall("pluginManagement", needIndent = true) {
-                sectionCall("repositories") {
-                    repositories.listNl()
+                pluginManagementIrs.irsOfTypeOrNull<PluginManagementRepositoryIR>()?.let { repositories ->
+                    sectionCall("repositories") {
+                        repositories.listNl()
+                    }
                }
+                nl()
+                freeIrs().listNl()
            }
-            nl(lineBreaks = 2)
        }
+        nl()
+
        +"rootProject.name = "; +projectName.quotified
        nl(lineBreaks = 2)
        if (subProjects.isNotEmpty()) {
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.tools.projectWizard.moduleConfigurators
+
+import org.jetbrains.kotlin.tools.projectWizard.Versions
+import org.jetbrains.kotlin.tools.projectWizard.core.*
+import org.jetbrains.kotlin.tools.projectWizard.core.entity.PluginSettingReference
+import org.jetbrains.kotlin.tools.projectWizard.core.entity.SettingType
+import org.jetbrains.kotlin.tools.projectWizard.core.entity.reference
+import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.gradle.AndroidConfigIR
+import org.jetbrains.kotlin.tools.projectWizard.plugins.AndroidPlugin
+import org.jetbrains.kotlin.tools.projectWizard.plugins.kotlin.ModuleConfigurationData
+import org.jetbrains.kotlin.tools.projectWizard.plugins.kotlin.ModuleType
+import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.Module
+import org.jetbrains.kotlin.tools.projectWizard.settings.javaPackage
+import org.jetbrains.kotlin.tools.projectWizard.core.entity.ModuleConfiguratorSetting
+import org.jetbrains.kotlin.tools.projectWizard.core.service.kotlinVersionKind
+import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.*
+import org.jetbrains.kotlin.tools.projectWizard.library.MavenArtifact
+import org.jetbrains.kotlin.tools.projectWizard.phases.GenerationPhase
+import org.jetbrains.kotlin.tools.projectWizard.plugins.kotlin.KotlinPlugin
+import org.jetbrains.kotlin.tools.projectWizard.plugins.kotlin.ModuleSubType
+import org.jetbrains.kotlin.tools.projectWizard.plugins.templates.TemplatesPlugin
+import org.jetbrains.kotlin.tools.projectWizard.settings.DisplayableSettingItem
+import org.jetbrains.kotlin.tools.projectWizard.settings.JavaPackage
+import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.DefaultRepository
+import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.Repository
+import org.jetbrains.kotlin.tools.projectWizard.settings.version.Version
+import org.jetbrains.kotlin.tools.projectWizard.templates.FileTemplate
+import org.jetbrains.kotlin.tools.projectWizard.templates.FileTemplateDescriptor
+import java.nio.file.Path
+
+interface AndroidModuleConfigurator : ModuleConfigurator,
+    ModuleConfiguratorWithSettings,
+    ModuleConfiguratorWithModuleType,
+    GradleModuleConfigurator {
+
+    override val moduleType: ModuleType
+        get() = ModuleType.jvm
+    override val greyText: String
+        get() = "Requires Android SDK"
+
+    override fun getPluginSettings(): List<PluginSettingReference<Any, SettingType<Any>>> =
+        listOf(AndroidPlugin::androidSdkPath.reference)
+
+    override fun createBuildFileIRs(
+        readingContext: ReadingContext,
+        configurationData: ModuleConfigurationData,
+        module: Module
+    ) = buildList<BuildSystemIR> {
+        +GradleOnlyPluginByNameIR(readingContext.createAndroidPlugin(module).pluginName)
+
+        +GradleOnlyPluginByNameIR("kotlin-android-extensions")
+        +AndroidConfigIR(
+            when (readingContext.createAndroidPlugin(module)) {
+                AndroidGradlePlugin.APPLICATION -> module.javaPackage(configurationData.pomIr)
+                AndroidGradlePlugin.LIBRARY -> null
+            }
+        )
+        +createRepositories(configurationData.kotlinVersion).map(::RepositoryIR)
+    }
+
+    fun ReadingContext.createAndroidPlugin(module: Module): AndroidGradlePlugin
+
+    override fun ReadingContext.createSettingsGradleIRs(module: Module) = buildList<BuildSystemIR> {
+        +createRepositories(KotlinPlugin::version.propertyValue).map { PluginManagementRepositoryIR(RepositoryIR(it)) }
+        +AndroidResolutionStrategyIR(Versions.GradlePlugins.ANDROID)
+    }
+
+    override fun createModuleIRs(
+        readingContext: ReadingContext,
+        configurationData: ModuleConfigurationData,
+        module: Module
+    ): List<BuildSystemIR> =
+        buildList {
+            +ArtifactBasedLibraryDependencyIR(
+                MavenArtifact(DefaultRepository.GOOGLE, "androidx.core", "core-ktx"),
+                version = Version.fromString("1.1.0"),
+                dependencyType = DependencyType.MAIN
+            )
+        }
+
+
+    override fun createStdlibType(configurationData: ModuleConfigurationData, module: Module): StdlibType? =
+        StdlibType.StdlibJdk7
+
+    object FileTemplateDescriptors {
+        val activityMainXml = FileTemplateDescriptor(
+            "android/activity_main.xml.vm",
+            "src" / "main" / "res" / "layout" / "activity_main.xml"
+        )
+
+        val androidManifestXml = FileTemplateDescriptor(
+            "android/AndroidManifest.xml.vm",
+            "src" / "main" / "AndroidManifest.xml"
+        )
+
+        val androidanifestForLibraryXml = FileTemplateDescriptor(
+            "android/AndroidManifestLibrary.xml.vm",
+            "src" / "main" / "AndroidManifest.xml"
+        )
+
+        fun mainActivityKt(javaPackage: JavaPackage) = FileTemplateDescriptor(
+            "android/MainActivity.kt.vm",
+            "src" / "main" / "java" / javaPackage.asPath() / "MainActivity.kt"
+        )
+    }
+
+    companion object {
+        fun createRepositories(kotlinVersion: Version) = buildList<Repository> {
+            +DefaultRepository.GRADLE_PLUGIN_PORTAL
+            +DefaultRepository.GOOGLE
+            +DefaultRepository.JCENTER
+            addIfNotNull(kotlinVersion.kotlinVersionKind.repository)
+        }
+    }
+}
+
+object AndroidTargetConfigurator : TargetConfigurator,
+    SimpleTargetConfigurator,
+    AndroidModuleConfigurator,
+    SingleCoexistenceTargetConfigurator,
+    ModuleConfiguratorSettings() {
+    override val moduleSubType = ModuleSubType.android
+    override val moduleType = ModuleType.jvm
+
+    override fun ReadingContext.createAndroidPlugin(module: Module): AndroidGradlePlugin =
+        withSettingsOf(module) { androidPlugin.reference.settingValue }
+
+    override fun getConfiguratorSettings() = buildList<ModuleConfiguratorSetting<*, *>> {
+        +super.getConfiguratorSettings()
+        +androidPlugin
+    }
+
+    override fun WritingContext.runArbitraryTask(
+        configurationData: ModuleConfigurationData,
+        module: Module,
+        modulePath: Path
+    ): TaskResult<Unit> = computeM {
+        val javaPackage = module.javaPackage(configurationData.pomIr)
+        val settings = mapOf("package" to javaPackage)
+        TemplatesPlugin::addFileTemplates.execute(
+            listOf(
+                FileTemplate(AndroidModuleConfigurator.FileTemplateDescriptors.androidanifestForLibraryXml, modulePath, settings)
+            )
+        )
+    }
+
+    val androidPlugin by enumSetting<AndroidGradlePlugin>("Android Library", neededAtPhase = GenerationPhase.PROJECT_GENERATION)
+}
+
+enum class AndroidGradlePlugin(override val text: String, val pluginName: String) : DisplayableSettingItem {
+    APPLICATION("Android Application", "com.android.application"),
+    LIBRARY("Android Library", "com.android.library")
+}
@@ -1,75 +1,62 @@
 package org.jetbrains.kotlin.tools.projectWizard.moduleConfigurators

 import org.jetbrains.kotlin.tools.projectWizard.core.*
-import org.jetbrains.kotlin.tools.projectWizard.core.entity.PluginSettingReference
-import org.jetbrains.kotlin.tools.projectWizard.core.entity.SettingType
-import org.jetbrains.kotlin.tools.projectWizard.core.entity.reference
-import org.jetbrains.kotlin.tools.projectWizard.core.service.kotlinVersionKind
 import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.*
-import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.gradle.AndroidConfigIR
-import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.gradle.BuildScriptDependencyIR
-import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.gradle.BuildScriptRepositoryIR
-import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.gradle.RawGradleIR
 import org.jetbrains.kotlin.tools.projectWizard.library.MavenArtifact
-import org.jetbrains.kotlin.tools.projectWizard.plugins.AndroidPlugin
 import org.jetbrains.kotlin.tools.projectWizard.plugins.kotlin.ModuleConfigurationData
-import org.jetbrains.kotlin.tools.projectWizard.plugins.kotlin.ModuleType
 import org.jetbrains.kotlin.tools.projectWizard.plugins.templates.TemplatesPlugin
-import org.jetbrains.kotlin.tools.projectWizard.settings.JavaPackage
 import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.DefaultRepository
 import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.Module
-import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.Repository
 import org.jetbrains.kotlin.tools.projectWizard.settings.javaPackage
 import org.jetbrains.kotlin.tools.projectWizard.settings.version.Version
 import org.jetbrains.kotlin.tools.projectWizard.templates.FileTemplate
-import org.jetbrains.kotlin.tools.projectWizard.templates.FileTemplateDescriptor
 import java.nio.file.Path

-object AndroidSinglePlatformModuleConfigurator : ModuleConfiguratorWithSettings,
+object AndroidSinglePlatformModuleConfigurator :
    SinglePlatformModuleConfigurator,
-    AndroidModuleConfigurator,
-    ModuleConfiguratorWithModuleType {
-    override val moduleType = ModuleType.jvm
+    AndroidModuleConfigurator {
    override val id = "android"
    override val suggestedModuleName = "android"
    override val text = "Android"
-    override val greyText = "Requires Android SDK"

-    private fun createRepositories(configurationData: ModuleConfigurationData) = buildList<Repository> {
-        +DefaultRepository.GRADLE_PLUGIN_PORTAL
-        +DefaultRepository.GOOGLE
-        +DefaultRepository.JCENTER
-        addIfNotNull(configurationData.kotlinVersion.kotlinVersionKind.repository)
-    }
-
-
-    override fun ReadingContext.createBuildFileIRs(
+    override fun createBuildFileIRs(
+        readingContext: ReadingContext,
        configurationData: ModuleConfigurationData,
        module: Module
-    ) =
-        buildList<BuildSystemIR> {
-            +GradleOnlyPluginByNameIR("com.android.application")
+    ) = buildList<BuildSystemIR> {
+        +super<AndroidModuleConfigurator>.createBuildFileIRs(readingContext, configurationData, module)

-            // it is explicitly here instead of by `createKotlinPluginIR` as it should be after `com.android.application`
-            +KotlinBuildSystemPluginIR(
-                KotlinBuildSystemPluginIR.Type.android,
-                version = null // Version is already present in the parent buildfile
-            )
-            +GradleOnlyPluginByNameIR("kotlin-android-extensions")
-            +AndroidConfigIR(module.javaPackage(configurationData.pomIr))
-            +createRepositories(configurationData).map(::RepositoryIR)
-        }
+        // it is explicitly here instead of by `createKotlinPluginIR` as it should be after `com.android.application`
+        +KotlinBuildSystemPluginIR(
+            KotlinBuildSystemPluginIR.Type.android,
+            version = configurationData.kotlinVersion
+        )
+    }.sortedBy { ir: BuildSystemIR ->
+        if (ir is GradleOnlyPluginByNameIR) {
+            // TODO implement proper sort on irs
+            // But for now kotlin-android-extensions should be after Android kotlin plugin
+            if (ir.pluginId == "kotlin-android-extensions") 1 else 0
+        } else 0
+    }

-    override fun createRootBuildFileIrs(configurationData: ModuleConfigurationData) = buildList<BuildSystemIR> {
-        +createRepositories(configurationData).map { BuildScriptRepositoryIR(RepositoryIR(it)) }
-        +listOf(
-            RawGradleIR { call("classpath") { +"com.android.tools.build:gradle:3.2.1".quotified } },
-            RawGradleIR {
-                call("classpath") {
-                    +"org.jetbrains.kotlin:kotlin-gradle-plugin:${configurationData.kotlinVersion}".quotified
-                }
-            }
-        ).map(::BuildScriptDependencyIR)
+    override fun createModuleIRs(
+        readingContext: ReadingContext,
+        configurationData: ModuleConfigurationData,
+        module: Module
+    ) = buildList<BuildSystemIR> {
+        +super<AndroidModuleConfigurator>.createModuleIRs(readingContext, configurationData, module)
+
+        +ArtifactBasedLibraryDependencyIR(
+            MavenArtifact(DefaultRepository.GOOGLE, "androidx.appcompat", "appcompat"),
+            version = Version.fromString("1.1.0"),
+            dependencyType = DependencyType.MAIN
+        )
+
+        +ArtifactBasedLibraryDependencyIR(
+            MavenArtifact(DefaultRepository.GOOGLE, "androidx.constraintlayout", "constraintlayout"),
+            version = Version.fromString("1.1.3"),
+            dependencyType = DependencyType.MAIN
+        )
    }

    override fun WritingContext.runArbitraryTask(
@@ -78,56 +65,16 @@ object AndroidSinglePlatformModuleConfigurator : ModuleConfiguratorWithSettings,
        modulePath: Path
    ): TaskResult<Unit> = computeM {
        val javaPackage = module.javaPackage(configurationData.pomIr)
+        val settings = mapOf("package" to javaPackage)
        TemplatesPlugin::addFileTemplates.execute(
            listOf(
-                FileTemplate(FileTemplateDescriptors.activityMainXml, modulePath, "package" to javaPackage),
-                FileTemplate(FileTemplateDescriptors.androidManifestXml, modulePath, "package" to javaPackage),
-                FileTemplate(FileTemplateDescriptors.mainActivityKt(javaPackage), modulePath, "package" to javaPackage)
+                FileTemplate(AndroidModuleConfigurator.FileTemplateDescriptors.activityMainXml, modulePath, settings),
+                FileTemplate(AndroidModuleConfigurator.FileTemplateDescriptors.androidManifestXml, modulePath, settings),
+                FileTemplate(AndroidModuleConfigurator.FileTemplateDescriptors.mainActivityKt(javaPackage), modulePath, settings)
            )
        )
    }

-    override fun ReadingContext.createModuleIRs(configurationData: ModuleConfigurationData, module: Module): List<BuildSystemIR> =
-        buildList {
-            +ArtifactBasedLibraryDependencyIR(
-                MavenArtifact(DefaultRepository.GOOGLE, "androidx.appcompat", "appcompat"),
-                version = Version.fromString("1.1.0"),
-                dependencyType = DependencyType.MAIN
-            )
-
-            +ArtifactBasedLibraryDependencyIR(
-                MavenArtifact(DefaultRepository.GOOGLE, "androidx.core", "core-ktx"),
-                version = Version.fromString("1.1.0"),
-                dependencyType = DependencyType.MAIN
-            )
-
-            +ArtifactBasedLibraryDependencyIR(
-                MavenArtifact(DefaultRepository.GOOGLE, "androidx.constraintlayout", "constraintlayout"),
-                version = Version.fromString("1.1.3"),
-                dependencyType = DependencyType.MAIN
-            )
-        }
-
-    override fun createStdlibType(configurationData: ModuleConfigurationData, module: Module): StdlibType? =
-        StdlibType.StdlibJdk7
-
-    override fun getPluginSettings(): List<PluginSettingReference<Any, SettingType<Any>>> =
-        listOf(AndroidPlugin::androidSdkPath.reference)
-
-    private object FileTemplateDescriptors {
-        val activityMainXml = FileTemplateDescriptor(
-            "android/activity_main.xml.vm",
-            "src" / "main" / "res" / "layout" / "activity_main.xml"
-        )
-
-        val androidManifestXml = FileTemplateDescriptor(
-            "android/AndroidManifest.xml.vm",
-            "src" / "main" / "AndroidManifest.xml"
-        )
-
-        fun mainActivityKt(javaPackage: JavaPackage) = FileTemplateDescriptor(
-            "android/MainActivity.kt.vm",
-            "src" / "main" / "java" / javaPackage.asPath() / "MainActivity.kt"
-        )
-    }
+    override fun ReadingContext.createAndroidPlugin(module: Module): AndroidGradlePlugin =
+        AndroidGradlePlugin.APPLICATION
 }
@@ -35,7 +35,8 @@ object JsSingleplatformModuleConfigurator : JSConfigurator, ModuleConfiguratorWi
            version = configurationData.kotlinVersion
        )

-    override fun ReadingContext.createBuildFileIRs(
+    override fun createBuildFileIRs(
+        readingContext: ReadingContext,
        configurationData: ModuleConfigurationData,
        module: Module
    ): List<BuildSystemIR> = buildList {
@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.*
 import org.jetbrains.kotlin.tools.projectWizard.settings.version.Version
 import java.nio.file.Path
 import kotlin.properties.ReadOnlyProperty
-import kotlin.reflect.KClass


 sealed class ModuleCondifuratorSettingsEnvironment {
@@ -205,13 +204,18 @@ interface ModuleConfigurator : DisplayableSettingItem, EntitiesOwnerDescriptor {
    val suggestedModuleName: String? get() = null
    val canContainSubModules: Boolean get() = false

-    fun ReadingContext.createBuildFileIRs(
+    fun createBuildFileIRs(
+        readingContext: ReadingContext,
        configurationData: ModuleConfigurationData,
        module: Module
    ): List<BuildSystemIR> =
        emptyList()

-    fun ReadingContext.createModuleIRs(configurationData: ModuleConfigurationData, module: Module): List<BuildSystemIR> =
+    fun createModuleIRs(
+        readingContext: ReadingContext,
+        configurationData: ModuleConfigurationData,
+        module: Module
+    ): List<BuildSystemIR> =
        emptyList()

    fun createStdlibType(configurationData: ModuleConfigurationData, module: Module): StdlibType? =
@@ -266,4 +270,8 @@ interface ModuleConfigurator : DisplayableSettingItem, EntitiesOwnerDescriptor {
                configurator
            }
    }
+}
+
+interface GradleModuleConfigurator : ModuleConfigurator {
+    fun ReadingContext.createSettingsGradleIRs(module: Module): List<BuildSystemIR> = emptyList()
 }
@@ -39,19 +39,26 @@ interface ModuleConfiguratorWithTests : ModuleConfiguratorWithSettings {

    fun defaultTestFramework(): KotlinTestFramework

-    override fun ReadingContext.createModuleIRs(configurationData: ModuleConfigurationData, module: Module): List<BuildSystemIR> =
+    override fun createModuleIRs(
+        readingContext: ReadingContext,
+        configurationData: ModuleConfigurationData,
+        module: Module
+    ): List<BuildSystemIR> =
        withSettingsOf(module) {
-            testFramework.reference.settingValue.dependencyNames.map { dependencyName ->
-                KotlinArbitraryDependencyIR(
-                    dependencyName,
-                    isInMppModule = module.kind
-                        .let { it == ModuleKind.multiplatform || it == ModuleKind.target },
-                    version = KotlinPlugin::version.propertyValue,
-                    dependencyType = DependencyType.TEST
-                )
+            with(readingContext) {
+                testFramework.reference.settingValue.dependencyNames.map { dependencyName ->
+                    KotlinArbitraryDependencyIR(
+                        dependencyName,
+                        isInMppModule = module.kind
+                            .let { it == ModuleKind.multiplatform || it == ModuleKind.target },
+                        version = KotlinPlugin::version.propertyValue,
+                        dependencyType = DependencyType.TEST
+                    )
+                }
            }
        }

+
    override fun getConfiguratorSettings(): List<ModuleConfiguratorSetting<*, *>> = listOf(testFramework)
 }

@@ -74,7 +74,8 @@ object NativeForCurrentSystemTarget : NativeTargetConfigurator, SingleCoexistenc
        }
    }

-    override fun ReadingContext.createBuildFileIRs(
+    override fun createBuildFileIRs(
+        readingContext: ReadingContext,
        configurationData: ModuleConfigurationData,
        module: Module
    ): List<BuildSystemIR> = buildList {
@@ -123,10 +123,3 @@ object JvmTargetConfigurator : JvmModuleConfigurator,
        }
    }
 }
-
-object AndroidTargetConfigurator : TargetConfigurator,
-    SimpleTargetConfigurator,
-    AndroidModuleConfigurator,
-    SingleCoexistenceTargetConfigurator {
-    override val moduleSubType = ModuleSubType.android
-}
@@ -43,7 +43,6 @@ enum class TargetJvmVersion(val value: String) : DisplayableSettingItem {
        get() = value
 }

-interface AndroidModuleConfigurator : ModuleConfigurator

 interface ModuleConfiguratorWithModuleType : ModuleConfigurator {
    val moduleType: ModuleType
@@ -89,11 +88,19 @@ object JvmSinglePlatformModuleConfigurator : JvmModuleConfigurator,
        )


-    override fun ReadingContext.createBuildFileIRs(configurationData: ModuleConfigurationData, module: Module): List<BuildSystemIR> =
+    override fun createBuildFileIRs(
+        readingContext: ReadingContext,
+        configurationData: ModuleConfigurationData,
+        module: Module
+    ): List<BuildSystemIR> =
        buildList {
            +GradleImportIR("org.jetbrains.kotlin.gradle.tasks.KotlinCompile")

-            val targetVersionValue = withSettingsOf(module) { JvmModuleConfigurator.targetJvmVersion.reference.settingValue.value }
+            val targetVersionValue = withSettingsOf(module) {
+                with(readingContext) {
+                    JvmModuleConfigurator.targetJvmVersion.reference.settingValue.value
+                }
+            }
            when {
                configurationData.buildSystemType.isGradle -> {
                    +GradleConfigureTaskIR(
@@ -3,6 +3,8 @@ package org.jetbrains.kotlin.tools.projectWizard.plugins.buildSystem.gradle
 import org.jetbrains.kotlin.tools.projectWizard.core.*
 import org.jetbrains.kotlin.tools.projectWizard.core.entity.reference
 import org.jetbrains.kotlin.tools.projectWizard.core.service.FileSystemWizardService
+import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.BuildSystemIR
+import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.PluginManagementRepositoryIR
 import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.RepositoryIR
 import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.gradle.SettingsGradleFileIR
 import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.render
@@ -36,6 +38,8 @@ abstract class GradlePlugin(context: Context) : BuildSystemPlugin(context) {

    val gradleProperties by listProperty<Pair<String, String>>()

+    val settingsGradleFileIRs by listProperty<BuildSystemIR>()
+
    val createGradlePropertiesFile by pipelineTask(GenerationPhase.PROJECT_GENERATION) {
        runAfter(KotlinPlugin::createModules)
        runBefore(TemplatesPlugin::renderFileTemplates)
@@ -105,6 +109,7 @@ abstract class GradlePlugin(context: Context) : BuildSystemPlugin(context) {


    val createSettingsFileTask by pipelineTask(GenerationPhase.PROJECT_GENERATION) {
+        runAfter(KotlinPlugin::createModules)
        runAfter(KotlinPlugin::createPluginRepositories)
        isAvailable = isGradle
        withAction {
@@ -115,11 +120,12 @@ abstract class GradlePlugin(context: Context) : BuildSystemPlugin(context) {
                if (isNotEmpty()) {
                    +RepositoryIR(DefaultRepository.MAVEN_CENTRAL)
                }
-            }
+            }.map(::PluginManagementRepositoryIR)
+
            val settingsGradleIR = SettingsGradleFileIR(
                StructurePlugin::name.settingValue,
                allModulesPaths.map { path -> path.joinToString(separator = "") { ":$it" } },
-                repositories
+                repositories + GradlePlugin::settingsGradleFileIRs.propertyValue
            )
            val buildFileText = createBuildFile().printBuildFile { settingsGradleIR.render(this) }
            service<FileSystemWizardService>().createFile(
@@ -3,8 +3,10 @@ package org.jetbrains.kotlin.tools.projectWizard.plugins.kotlin
 import org.jetbrains.kotlin.tools.projectWizard.core.*
 import org.jetbrains.kotlin.tools.projectWizard.ir.buildsystem.*
 import org.jetbrains.kotlin.tools.projectWizard.moduleConfigurators.AndroidSinglePlatformModuleConfigurator
+import org.jetbrains.kotlin.tools.projectWizard.moduleConfigurators.GradleModuleConfigurator
 import org.jetbrains.kotlin.tools.projectWizard.moduleConfigurators.TargetConfigurator
 import org.jetbrains.kotlin.tools.projectWizard.plugins.buildSystem.BuildSystemType
+import org.jetbrains.kotlin.tools.projectWizard.plugins.buildSystem.gradle.GradlePlugin
 import org.jetbrains.kotlin.tools.projectWizard.plugins.buildSystem.isGradle
 import org.jetbrains.kotlin.tools.projectWizard.settings.buildsystem.*
 import org.jetbrains.kotlin.tools.projectWizard.settings.version.Version
@@ -102,7 +104,7 @@ class ModulesToIRsConverter(
            +module.sourcesets.flatMap { sourceset ->
                sourceset.dependencies.map { it.toIR(sourceset.sourcesetType.toDependencyType()) }
            }
-            with(configurator) { +createModuleIRs(data, module) }
+            with(configurator) { +createModuleIRs(this@createSinglePlatformModule, data, module) }
            addIfNotNull(
                configurator.createStdlibType(data, module)?.let { stdlibType ->
                    KotlinStdlibDependencyIR(
@@ -160,7 +162,7 @@ class ModulesToIRsConverter(
        }

        val targetModuleIrs = module.subModules.map { target ->
-            createTargetSourceset(target, modulePath)
+            createTargetModule(target, modulePath)
        }

        return BuildFileIR(
@@ -179,7 +181,8 @@ class ModulesToIRsConverter(
        ).asSingletonList().asSuccess()
    }

-    private fun ReadingContext.createTargetSourceset(target: Module, modulePath: Path): MultiplatformModuleIR {
+    private fun ReadingContext.createTargetModule(target: Module, modulePath: Path): MultiplatformModuleIR {
+        data.writingContext.mutateProjectStructureByModuleConfigurator(target, modulePath)
        val sourcesetss = target.sourcesets.map { sourceset ->
            val sourcesetName = target.name + sourceset.sourcesetType.name.capitalize()
            val sourcesetIrs = buildList<BuildSystemIR> {
@@ -208,7 +211,7 @@ class ModulesToIRsConverter(
        return MultiplatformModuleIR(
            target.name,
            modulePath,
-            with(target.configurator) { createModuleIRs(data, target) },
+            with(target.configurator) { createModuleIRs(this@createTargetModule, data, target) },
            target.template,
            target,
            sourcesetss
@@ -219,8 +222,13 @@ class ModulesToIRsConverter(
        module: Module,
        modulePath: Path
    ): TaskResult<Unit> = with(module.configurator) {
-        rootBuildFileIrs += createRootBuildFileIrs(data)
-        runArbitraryTask(data, module, modulePath)
+        compute {
+            rootBuildFileIrs += createRootBuildFileIrs(data)
+            runArbitraryTask(data, module, modulePath).ensure()
+            if (this@with is GradleModuleConfigurator) {
+                GradlePlugin::settingsGradleFileIRs.addValues(createSettingsGradleIRs(module)).ensure()
+            }
+        }
    }

    private fun ReadingContext.createBuildFileIRs(
@@ -239,7 +247,7 @@ class ModulesToIRsConverter(
                }
            }
        addIfNotNull(kotlinPlugin)
-        +with(module.configurator) { createBuildFileIRs(data, module) }
+        +with(module.configurator) { createBuildFileIRs(this@createBuildFileIRs, data, module) }
    }

    private fun SourcesetDependency.toIR(type: DependencyType): DependencyIR = with(data) {