Confronta Lightbuild con Kotlin DSL

Se hai familiarità con la configurazione delle build Android con Kotlin DSL, questa pagina mostra come le configurazioni Kotlin DSL comuni vengono mappate a Lightbuild.

Gli esempi in questa pagina utilizzano Kotlin DSL e il plug-in Android per Gradle (AGP) 9.0 o versioni successive, che include il supporto integrato di Kotlin.

File di build

La tabella seguente mostra l'equivalente Lightbuild di ogni file di build Kotlin DSL:

Impostazioni progetto

In Kotlin DSL, il file settings.gradle.kts definisce il nome del progetto, i suoi moduli e i repository da cui risolvere le dipendenze:

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}

rootProject.name = "MyApp"
include(":app")
include(":app-core")

In Lightbuild, il file project.lightbuild.yaml definisce le stesse impostazioni:

project:
  name: MyApp
modules:
  - app
  - app-core
repositories:
  - google
  - mavenCentral

La tabella seguente mette a confronto le impostazioni a livello di progetto:

Tipo di modulo e plug-in

In Kotlin DSL, scegli il tipo di modulo applicando un plug-in e applichi altri plug-in per aggiungere funzionalità come KSP. In Lightbuild, imposti il type del modulo e Lightbuild applica le funzionalità necessarie per la tua configurazione:

Impostazioni di Android

In Kotlin DSL, configura le impostazioni di Android nel blocco android del file build.gradle.kts di un modulo:

plugins {
    id("com.android.application")
}

android {
    namespace = "com.example.myapp.app"
    compileSdk = 36

    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 24
        targetSdk = 36
        versionCode = 1
        versionName = "1.0"
    }
}

In Lightbuild, configuri le stesse impostazioni nel blocco android del file lightbuild.yaml di un modulo:

platform: android
type: application
android:
  namespace: com.example.myapp.app
  compileSdk:
    version:
      release:
        apiLevel: 36
  minSdk:
    version:
      release:
        apiLevel: 24
  targetSdk:
    version:
      release:
        apiLevel: 36
  applicationId: com.example.myapp
  versionCode: 1
  versionName: "1.0"

La tabella seguente mette a confronto queste impostazioni:

Dipendenze

In Kotlin DSL, dichiari le dipendenze nel blocco dependencies, utilizzando configurazioni come implementation:

dependencies {
    implementation(project(":app-core"))
    implementation("androidx.core:core-ktx:1.18.0")
}

In Lightbuild, elenchi le dipendenze dei moduli in module e le librerie esterne in maven:

android:
  dependencies:
    module:
      - //app-core
    maven:
      - androidx.core:core-ktx:1.18.0

Kotlin DSL utilizza altre configurazioni, come api, compileOnly e runtimeOnly, per controllare il modo in cui un modulo utilizza una dipendenza:

dependencies {
    api(project(":data"))
    compileOnly("androidx.annotation:annotation:1.9.1")
}

In Lightbuild, aggiungi invece le impostazioni compile e runtime alla dipendenza:

android:
  dependencies:
    module:
      - //data:
          compile: public
    maven:
      - androidx.annotation:annotation:1.9.1:
          runtime: off

Per ulteriori informazioni su queste impostazioni, consulta Impostazioni delle dipendenze.

La tabella seguente mette a confronto le dichiarazioni di dipendenza comuni:

KSP

In Kotlin DSL, applichi il plug-in KSP e aggiungi i processori con la configurazione ksp:

plugins {
    id("com.android.library")
    id("com.google.devtools.ksp")
}

dependencies {
    implementation("com.squareup.moshi:moshi:1.15.2")
    implementation("com.squareup.moshi:moshi-kotlin:1.15.2")
    ksp("com.squareup.moshi:moshi-kotlin-codegen:1.15.2")
}

In Lightbuild, aggiungi i processori al blocco kspProcessors e Lightbuild applica automaticamente il plug-in KSP:

type: library
android:
  dependencies:
    maven:
      - com.squareup.moshi:moshi:1.15.2
      - com.squareup.moshi:moshi-kotlin:1.15.2
  kspProcessors:
    maven:
      - com.squareup.moshi:moshi-kotlin-codegen:1.15.2

Test

In Kotlin DSL, imposti l'esecutore dei test di instrumentazione in defaultConfig e aggiungi le dipendenze di test con le configurazioni testImplementation e androidTestImplementation:

android {
    defaultConfig {
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }
}

dependencies {
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.3.0")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.7.0")
}

In Lightbuild, configuri i test locali in tests.test e i test di instrumentazione in tests.androidTest:

android:
  tests:
    test:
      dependencies:
        maven:
          - junit:junit:4.13.2
    androidTest:
      runner: androidx.test.runner.AndroidJUnitRunner
      dependencies:
        maven:
          - androidx.test.ext:junit:1.3.0
          - androidx.test.espresso:espresso-core:3.7.0

Comandi di build

Con Kotlin DSL, puoi creare ed eseguire test dalla riga di comando eseguendo le attività Gradle con il wrapper Gradle. Con Lightbuild, utilizzi l'interfaccia a riga di comando di Lightbuild.

Per saperne di più, consulta Crea la tua app dalla riga di comando e Crea progetti Lightbuild dalla riga di comando.

Blocco delle dipendenze

Con Kotlin DSL, il blocco delle dipendenze è facoltativo: lo attivi negli script di build e poi scrivi i file di blocco eseguendo una build con il flag --write-locks. In Lightbuild, ogni modulo ha un file resolved.deps che registra le dipendenze risolte del modulo, che Lightbuild genera automaticamente. Come per i file di blocco Gradle, esegui il commit dei file resolved.deps nel controllo della versione.

Per bloccare le dipendenze, ad esempio in una build CI, aggiungi il flag --locked-dependencies a lightbuild resolve o lightbuild test. Con questo flag, il comando non va a buon fine se un file resolved.deps non corrisponde alle dipendenze del modulo, anziché aggiornare il file:

lightbuild resolve --locked-dependencies

Funzionalità non supportate

Lightbuild non supporta le seguenti funzionalità di Kotlin DSL:

• Cataloghi delle versioni e plug-in di convenzione
• Plug-in personalizzati
• Versioni prodotto. Crea invece un modulo dell'app separato per ogni versione della tua app. Per maggiori informazioni, consulta la sezione Più moduli dell'app.
• Moduli Kotlin Multiplatform (KMP)
• Risoluzione delle dipendenze tramite un server proxy

Inoltre, un progetto non può combinare moduli Kotlin DSL e Lightbuild. Per i problemi noti, consulta le note di rilascio di Lightbuild.