Android: ¡Adios Groovy! Migrar a Kotlin nuestro build.gradle
Tags: android, spanish, kotlin, tutorial
Published: 2023-05-30 14:29:09

Mis niños, hoy es un día un poco ajetreado, sin embargo me he caído de la cama y tengo energía para poder escribirles unas líneas ahora sobre un tema que nosotros hemos visto desde hace tiempo en el desarrollo de Android: migrar los archivos build.gradle a Kotlin.

Recientemente, en la documentación de Google se ha notificado que Kotlin Script (KTS) será el lenguaje por default ahora para la sincronización de dependencias y que a partir de la siguiente versión de Android Studio, este proceso será por default en nuevas apps, por lo que este pequeño tutorial podrá servirte para poder migrar un pequeño proyecto de Groovy a KTS.

## ¿Qué es KTS?

KTS es el acrónimo para Kotlin Script, en sí el migrar de lenguaje entre Groovy y Kotlin no quiere decir que vamos a cambiar el núcleo de la importación de librerías en Android, que seguirá haciéndose con Gradle. Para los nuevos, Gradle es una herramienta de construcción de aplicaciones y automatización de rutinas compatible con diversos lenguajes de programación; esta fue construida con Java y fue el sustituto de Ant cuando llegó Android Kit Kat (o un poco antes). 

Hay varias diferencias entre archivos KT y archivos KTS, una de ellas es que los archivos KT son interpretados por el compilador de Kotlin, mientras que los KTS por el soporte de Scripting de Kotlin, por lo que no necesitan una compilación previa (¿Javascript eres tú?) y en este caso es como Gradle lo tomaría en cuenta sin necesidad de compilarlo previamente.

## ¿Tarda mucho?

Pensarán muchos que esto es muy difícil y hasta tardado, pero en realidad es muy sencillo, pues solamente hay que cambiar cierta sintaxis dentro de los archivos build.gradle para conseguirlo, así que es hora de meter las manos al fuego

## 1. Cambiar el settings.gradle

Lo primero sería cambiar de nombre el archivo, agregándole la extensión **.kts** al archivo y tendrás la siguiente línea:

```groovy
include ':app'
```

En KTS, debes cambiarla por las siguientes:

```kotlin
include("app")
```

Ya no hay que hacer más en este archivo e inclusive si quieres probarlo, te dejará sincronizar tus dependencias. Ahora bien, es importante que no uses comillas simples ('), pues Kotlin te las interpretará como caracteres y te marcará error. Procura siempre usar comillas (") en las cadenas de caracteres para que no tengas ningún problema.

## 2. Cambiar el build.gradle raíz

Ahora bien, haz lo mismo de cambiar el nombre del archivo en el build.gradle raíz y cambia lo siguiente:

Si tienes asignadas variables de versión (en un nodo ext) haz lo siguiente. Cambia lo siguiente:

```groovy
buildscript {
    ext.androidGradleVersion = "8.0.1"
    ext.androidKotlinPlugin = "1.8.20"
}
```

Por esto:

```kotlin
buildscript {
    val androidGradlePlugin by extra("8.0.1")
    val androidKotlinPlugin by extra("1.8.20")
}
```

Aún no terminamos. Más abajo tendremos el nodo de **plugins**, cambiémoslo de esto:

```groovy
plugins {
    id "com.android.application:$androidGradleVersion"
    id "com.android.library:$androidGradleVersion"
    id "org.jetbrains.kotlin.android:$androidKotlinPlugin"
}
```

a esto

```kotlin
plugins {
    id("com.android.application") version "${extra["androidGradlePlugin"]}" apply false
    id("com.android.library") version "${extra["androidGradlePlugin"]}" apply false
    id("org.jetbrains.kotlin.android") version "${extra["androidKotlinPlugin"]}" apply false
}
```

Y ya tendremos listo este archivo, ahora es tiempo de pasar al archivo (o archivos) build.gradle de nuestros módulos.

## 3. Cambiar el build.gradle de nuestro módulo

En este caso cambiaremos el del módulo **app**, en este caso, si tienes más módulo, tendrás que hacer prácticamente lo mismo para el resto. Igual que los otros 2, cámbiale el nombre al archivo agregando extensión KTS al final. Luego cambia lo siguiente:

```groovy
plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
}
```

por esto:

```kotlin
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}
```

Igualmente en la parte de la definición de Android, agrega a todas las definiciones un signo de igual (=) a cada una de ellas, es decir, en lugar de esto:

```groovy
android {
    namespace 'mx.dev1.deadpool'
    compileSdk 33

    defaultConfig {
        applicationId "mx.dev1.deadpool"
        minSdk 24
        targetSdk 33
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
}
```
que quede esto:

```kotlin
android {
    namespace = "mx.dev1.foo"
    compileSdk = 33

    defaultConfig {
        applicationId = "mx.dev1.foo"
        minSdk = 24
        targetSdk = 33
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles (
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}
```

Finalmente, encierra entre paréntesis los nombres de tus implementaciones para que queden en vez de esto:

```groovy
dependencies {

    implementation 'androidx.core:core-ktx:1.8.0'
    implementation 'androidx.appcompat:appcompat:1.4.1'
    implementation 'com.google.android.material:material:1.5.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
    implementation 'androidx.navigation:navigation-fragment-ktx:2.5.3'
    implementation 'androidx.navigation:navigation-ui-ktx:2.5.3'
    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.6.1'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
}
```

quede esto:

```kotlin
dependencies {
    implementation("androidx.core:core-ktx:1.8.0")
    implementation("androidx.appcompat:appcompat:1.4.1")
    implementation("com.google.android.material:material:1.5.0")
    implementation("androidx.constraintlayout:constraintlayout:2.1.3")
    implementation("androidx.navigation:navigation-fragment-ktx:2.5.3")
    implementation("androidx.navigation:navigation-ui-ktx:2.5.3")
    implementation("androidx.legacy:legacy-support-v4:1.0.0")
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.6.1")
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1")
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.1.3")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.4.0")
}
```
###### (Best practice: Por ahorita, dejé las versiones de las dependencias "hardcoded", pero siempre tenlas en una variable adicional, en este caso los extras del paso 2.)

Ahora, una vez terminado, sincroniza tu proyecto.

Ya con esto habrás dejado actualizado tu proyecto para tenerlo con KTS y poder disfrutar de sus bondades, así como mantener actualizada tu aplicación.

Espero que este tutorial les haya servido y de ser así compártanlo con más banda para que puedan ver más contenido que les estaré trayendo en este pequeño blog.

Happy coding!