Adaptar Kotlin 2.0 en aplicaciones Android
Tags: kotlin, android, compose, k2
Published: 2024-06-01 18:06:06

> [Lee este post en inglés aquí.](https://dev.to/marlonlom/adapt-kotlin-20-in-android-applications-3cmk)

Recientemente, se ha liberado la versión 2.0 de Kotlin, y con ello, varios ajustes a los proyectos Android para adaptar o implementar código con esta nueva versión del lenguaje de programación oficialmente soportado por Google para desarrollo móvil Android (Multiplataforma, según las últimas versiones del evento Google I/O).

En este corto artículo, explico mi experiencia migrando de la versión `1.9.23` a la versión `2.0.0`; Esto, debido a las novedades que abarca el uso de esta nueva versión en proyectos que usan Kotlin como lenguaje de programación, y también la posible dificultad de muchos de nosotros los desarrolladores para aplicar migraciones desde versiones de Kotlin muy inferiores a la `1.9.0`.


## Acerca del compilador K2

El compilador K2 es una reimplementación completa del compilador Kotlin original, diseñado para ofrecer mejoras significativas en el desarrollo de aplicaciones Android. Introducido en Kotlin 2.0, K2 aporta varias ventajas, entre las que se destacan: mayor velocidad de compilación, mejoras en rendimiento, y soporte multiplataforma mejorado; Estas ventajas aplicadas a proyectos Android, permiten una reducción en el tamaño de las aplicaciones al generar código más compacto, así como la generación de código nativo lo cual implica mayor rendimiento en las aplicaciones móviles.


### ¿Cómo probar el compilador K2 en Android?

Cabe mencionar, en este apartado se cubre el aspecto de configuración desde el punto de vista de proyectos Android, no mencionaré detalles de KMP, aunque varios de los detalles indicados son fáciles de asimilar si uno ya tiene experiencia en proyectos multiplataforma usando Kotlin.


#### 1. Un nuevo directorio de compilación

Kotlin 2.0 presenta un nuevo directorio de salida de compilación: `.kotlin`. debes agregarlo al archivo `.gitignore` para que su contenido no aparezca en las confirmaciones:

```
# .gitignore 
# Kotlin 2.0
.kotlin/
```


#### 2. Aplicar nueva versión de kotlin

Ahora vamos al archivo gradle/libs.versions.toml, en este apartado, se asume se está utilizando Version Catalogs para controlar las dependencias de la aplicación móvil (versiones, plugins, etc.), Se localiza la referencia a la versión de Kotlin, y se cambia a la versión 2.0.0. así:

```
# gradle/libs.versions.toml
[versions]
agp = "8.4.1"
kotlin = "2.0.0"
ksp = "2.0.0-1.0.21"
```

A propósito de la compatibilidad, se debe actualizar también las versiones de las librerías Kotlin symbol processor (KSP) y el plugin gradle para Android (AGP, siglas usadas para referencia), en el snippet anterior se indican las versiones para revisión.

A nivel de librerías, se actualizan también las librerias de kotlin a continuación:

```
# gradle/libs.versions.toml
[libraries]
kotlin-gradle-plugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.0"
kotlin-serialization-plugin = "org.jetbrains.kotlin:kotlin-serialization:2.0.0"
```

> Nota: hay librerías que, al momento de la redacción del presente artículo, no presentaron inconvenientes en cuanto a cambio de versiones, como `kotlin-coroutines`, `kotlin-serialization`, `kotlin-serialization-json`.

A nivel de plugins, se actualizan también las librerias de kotlin a continuación, esto, tomando en cuenta la referencia de versión ya indicada previamente:

```
# gradle/libs.versions.toml
[plugins]
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
```

Con esto realizado, ejecutar el comando `gradle clean build` o desde Android Studio, hacer build del proyecto.


#### 3. Actualizar el compilador de Compose

Otro aspecto importante en cuanto a la configuración de proyectos Android, especialmente utilizando Jetpack Compose, es el relacionado con el compilador de Compose para Kotlin, el cual es una configuración que permite la transformación de funciones anotadas como `@Composable` en pro de aplicar optimizaciones en la compilación de dichas funciones, ahora, la forma de definir la versión del compilador de compose ha presentado un gran cambio, el cual se describe a continuación.

Anteriormente, se tenia que colocar la versión del compilador de compose dentro del archivo build.gradle del modulo del proyecto gradle que posea las implementaciones Android y que contengan también las implementaciones de Jetpack Compose.

```
/* build.gradle.kts */
…
composeOptions {
  kotlinCompilerExtensionVersion = "1.5.3"
}
…
```

Y en caso de utilizar Version Catalogs, se indicaría la versión de la siguiente manera:

```
# gradle/libs.versions.toml
[versions]
compose-compiler = “1.5.3”
…
```

```
/* build.gradle.kts */
…
composeOptions {
  kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
}
…
```

Esta iniciativa fue buena en su momento, pero presenta algunos problemas de mantenimiento, ya que se requiere que sea compatible con la versión actual de Kotlin. Es diferente de la versión Compose y el IDE no propuso mejorarla. Cada vez que se actualiza la versión de Kotlin, se tiene que buscar en la documentación de Jetpack Compose en Google la versión compatible del compilador Compose. Kotlin 2.0 soluciona este problema.

Ahora, se aplica en el archivo `gradle/libs.versions.toml` la inclusión de un nuevo plugin de gradle, que se encarga de manejar la versión del compilador de compose mas organizada y ligada a la versión de Kotlin. 

```
# gradle/libs.versions.toml
[plugins]
…
kotlin-compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
```

Luego de esta accion, se modifica el archivo `build.gradle.kts` del módulo Android que posea las capacidades de Jetpack Compose, removiendo la configuración `composeOptions. kotlinCompilerExtensionVersion ` y agregando la referencia al plugin  `kotlin-compose-compiler`  en la sección `plugins { .. }`.

```
/* build.gradle.kts */
…
plugins {
  …
  alias(libs.plugins.compose.compiler)
}
…
```

Con esto realizado, ejecutar el comando `gradle clean build` o desde Android Studio, hacer build del proyecto o sincronizar.

¡Y eso es todo! Este complemento configurará la versión del compilador Compose según la versión actual de Kotlin.


## Conclusiones 

En general, el compilador K2 representa un avance significativo para el desarrollo de aplicaciones Android con Kotlin. Las mejoras en la velocidad, el rendimiento y la extensibilidad lo convierten en una herramienta valiosa para los desarrolladores Android.

Ahora que ya se está volviendo como estándar el uso de Kotlin 2.0.0, Ahora es buen momento para actualizar nuestros aplicativos Android para que estos soporten más de la tecnología que va y va evolucionando en cuando a Kotlin, KMP, Jetpack Compose, y las demás tecnologías que desde Google y desarrolladores de apps y librerias móviles van adaptando para unas apps móviles mas modernas y con mejores prestaciones.

Espero que encuentres esto informativo y útil y que en algún momento puedas seguir estos pasos en tus aplicaciones de Android, en pro de aplicar una buena migración hacia Kotlin 2.0.0.

Gracias por leer, ¡feliz código! 😊