Nivel inicial13 min de lectura · Publicado el

Kotlin Android Extensions: qué fue y cómo migrar

Kotlin Android Extensions: findViewById, el acceso directo a la vista por su id de las extensiones (retirado) y binding.boton de View Binding. De synthetic a View Bindingrubentejera.com findViewById<Button>(R.id.botonPorId)boton.setOnClickListenerretiradobinding.botonView Binding
Antes había que buscar cada vista con findViewById; las extensiones dejaban usarla por su id, pero están obsoletas desde Kotlin 1.4.20 y retiradas. Hoy se usa View Binding: binding.boton, con el tipo correcto.

Qué pasó con el plugin, versión a versión

Versión de Kotlin Fecha Qué pasa si aplicas kotlin-android-extensions
Hasta 1.4.10 Antes de noviembre de 2020 Funciona sin avisos
1.4.20 a 1.7.x 23 de noviembre de 2020 Funciona, con un aviso: «The ‘kotlin-android-extensions’ Gradle plugin is deprecated»
1.8.0 a 2.3.x 28 de diciembre de 2022 El plugin sigue existiendo, pero el build falla: «The ‘kotlin-android-extensions’ Gradle plugin is no longer supported»
2.4.0 en adelante 3 de junio de 2026 El plugin ya no existe: Gradle no lo encuentra

Las fechas son las de la página oficial de versiones de Kotlin. Los mensajes de las filas 2 y 3 están dentro del plugin de Gradle de Kotlin publicado en Maven Central (versiones 1.7.22, 1.8.0 y 2.0.0); en la fila 3, el texto cambia a partir de 2.1.20, como se ve en los errores frecuentes. El de la última fila se ha ejecutado, más abajo, en errores frecuentes.

Qué usar hoy

Necesitas… Usa Desde
Acceder a las vistas de un layout XML View Binding (buildFeatures { viewBinding = true }) Parte del plugin de Android para Gradle; es el camino de la guía oficial de migración
Hacer una pantalla nueva Jetpack Compose, sin layouts XML ni ids En noviembre de 2026, la última lista de versiones estable (BOM) es la 2026.09.00, y androidx.compose.ui, la 1.12.1, del 9 de septiembre de 2026
Generar Parcelable con @Parcelize El plugin kotlin-parcelize y el import kotlinx.parcelize.Parcelize Sustituye a la parte de Parcelable del plugin antiguo
Expresiones y datos enlazados en el XML Data Binding Solo si necesitas esas funciones: View Binding compila más rápido

Qué hacían las Kotlin Android Extensions

Imagina un cajón de herramientas. Con findViewById tienes que buscar cada herramienta por su etiqueta y decir qué es («esto es un destornillador»). Con las extensiones, el cajón venía ya abierto y con cada herramienta a mano por su nombre.

En código, la diferencia era esta:

import kotlinx.android.synthetic.main.activity_kotlin_android_extensions.* // carga todas las vistas del layout

class KotlinAndroidExtensionsActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_kotlin_android_extensions)

        // Forma "tradicional", como en Java: buscar la vista por su id
        val btn = findViewById<Button>(R.id.botonPorId)
        btn.setOnClickListener {
            Toast.makeText(this, "Pulsado con findViewById", Toast.LENGTH_SHORT).show()
        }

        // Kotlin Android Extensions: la vista ya existe con el nombre de su id
        boton.setOnClickListener {
            Toast.makeText(this, "Pulsado con las extensiones", Toast.LENGTH_SHORT).show()
        }
    }
}

Con el import de kotlinx.android.synthetic se cargaba todo el layout y podías llamar al botón por el mismo nombre que su id, sin findViewById ni conversiones de tipo.

Por qué se retiró

Era cómodo, pero tenía trampas:

  • Espacio de nombres global: todas las vistas de un layout quedaban accesibles, y podías usar por error una vista de otro layout con el mismo id. Compilaba y fallaba en ejecución.
  • Sin seguridad ante nulos: si una vista solo existía en algunas variantes del layout, Kotlin no te avisaba.
  • Solo para Kotlin.

View Binding resuelve las tres cosas: genera una clase por layout, con los tipos correctos y marcando como opcionales las vistas que no están en todas las variantes.

Cómo migrar a View Binding

  1. Activa View Binding en el build.gradle.kts del módulo.
  2. Quita el plugin kotlin-android-extensions (si usas @Parcelize, pasa a kotlin-parcelize).
  3. Borra los imports de kotlinx.android.synthetic.
  4. Infla la clase de binding y cambia cada vista por binding.vista.

1. Gradle

// build.gradle.kts del módulo
android {
    buildFeatures {
        viewBinding = true
    }
}

2. La activity

Por cada layout se genera una clase con su nombre en PascalCase y Binding al final: activity_kotlin_android_extensions.xml pasa a ser ActivityKotlinAndroidExtensionsBinding.

class KotlinAndroidExtensionsActivity : AppCompatActivity() {

    private lateinit var binding: ActivityKotlinAndroidExtensionsBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityKotlinAndroidExtensionsBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // El id "boton" del XML se convierte en binding.boton
        binding.boton.setOnClickListener {
            Toast.makeText(this, "Pulsado con View Binding", Toast.LENGTH_SHORT).show()
        }
    }
}
Kotlin Android Extensions View Binding
Estado Retirado Recomendado en vistas XML
Acceso boton binding.boton
Comprueba el layout No Sí, una clase por layout
Funciona en Java No Sí

Si empiezas un proyecto nuevo, Google recomienda Jetpack Compose, donde no hay layouts XML ni ids que enlazar.

3. Los fragments: limpia el binding

Un fragment vive más que su vista. La documentación de View Binding pide guardar el binding en una variable que puede ser nula y vaciarla en onDestroyView(), para no retener una vista que ya no está en pantalla. [SIN EJECUTAR], como el resto del código de Android de este artículo:

class PerfilFragment : Fragment() {

    private var _binding: FragmentPerfilBinding? = null
    // Solo es válido entre onCreateView y onDestroyView
    private val binding get() = _binding!!

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = FragmentPerfilBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

Saber qué nombre tendrá cada vista

Al migrar, la duda más habitual es cómo se va a llamar cada cosa. La regla de la documentación es sencilla: el nombre del fichero del layout pasa a PascalCase (cada palabra con mayúscula, sin guiones bajos) y se le añade Binding; los ids con guiones bajos pasan a camelCase, como user_bio, que se convierte en userBio.

Esa regla se puede escribir y probar en Kotlin puro, sin Android. Te sirve como chuleta y para preparar la lista de cambios antes de tocar el proyecto:

import kotlin.test.assertEquals

// layout: activity_main.xml -> ActivityMainBinding
fun claseBinding(layout: String): String =
    layout.removeSuffix(".xml")
        .split('_')
        .joinToString("") { it.replaceFirstChar(Char::uppercaseChar) } + "Binding"

// id: @+id/boton_enviar -> binding.botonEnviar
fun campoBinding(id: String): String {
    val partes = id.removePrefix("@+id/").split('_')
    return partes.first() + partes.drop(1).joinToString("") { it.replaceFirstChar(Char::uppercaseChar) }
}

fun main() {
    assertEquals("ResultProfileBinding", claseBinding("result_profile.xml"))
    assertEquals("ActivityKotlinAndroidExtensionsBinding", claseBinding("activity_kotlin_android_extensions.xml"))
    assertEquals("boton", campoBinding("@+id/boton"))
    assertEquals("userBio", campoBinding("@+id/user_bio"))
    assertEquals("botonEnviar", campoBinding("boton_enviar"))
    println("5 comprobaciones superadas")
}

Las órdenes suponen kotlinc en el PATH y el zip oficial del compilador descomprimido en ./kotlinc, que es de donde sale kotlin-test.jar:

kotlinc NombresBinding.kt -cp kotlinc/lib/kotlin-test.jar -include-runtime -d nombres.jar
java -cp nombres.jar:kotlinc/lib/kotlin-test.jar NombresBindingKt
5 comprobaciones superadas

Las dos primeras comprobaciones son los ejemplos de la documentación oficial (result_profile.xml y user_bio). La función es una simplificación para nombres en minúsculas con guiones bajos, que es la convención de Android; el generador real lo hace el plugin de Android al compilar.

Con las extensiones, ese id con guion bajo se usaba tal cual (boton_enviar.setOnClickListener). Con View Binding pasa a binding.botonEnviar: es el cambio que más veces repetirás al migrar.

Errores frecuentes al migrar

1. «Plugin with id ‘kotlin-android-extensions’ not found»

Si actualizas Kotlin a la 2.4 sin quitar el plugin, el build no arranca. Con el plugin de Gradle de Kotlin 2.4.21 y apply(plugin = "kotlin-android-extensions"):

* What went wrong:
Plugin with id 'kotlin-android-extensions' not found.

Y con el bloque plugins { kotlin("android.extensions") version "2.4.21" }:

* What went wrong:
Plugin [id: 'org.jetbrains.kotlin.android.extensions', version: '2.4.21'] was not found in any of the following sources:

No es un problema de repositorios ni de caché: el plugin ya no existe. Quítalo del build.gradle.kts del módulo.

Entre Kotlin 1.8.0 y 2.3.x, el plugin todavía existe, pero el build falla. El texto del error lo lleva dentro el propio plugin y ha cambiado tres veces. De 1.8.0 a 2.1.10:

Error: The 'kotlin-android-extensions' Gradle plugin is no longer supported. Please use this migration guide (https://goo.gle/kotlin-android-extensions-deprecation) to start working with View Binding (https://developer.android.com/topic/libraries/view-binding) and the 'kotlin-parcelize' plugin.

Desde 2.1.20 pasa a ser uno de los diagnósticos del plugin de Gradle de Kotlin, con otro texto. De 2.1.20 a 2.2.10:

The 'kotlin-android-extensions' Gradle plugin is no longer supported and will be removed in future release.

Y de 2.2.20 a 2.3.21:

The 'kotlin-android-extensions' Gradle plugin is no longer supported and was removed.

En los dos últimos tramos, la solución que propone es la misma: «Please remove the ‘kotlin-android-extensions’ Gradle plugin from your build script» (quita el plugin de tu script de build).

2. «Unresolved reference ‘kotlinx’»

Al quitar el plugin, todos los imports sintéticos dejan de compilar. Lo mismo le pasa al import antiguo de @Parcelize, que también venía de ese plugin:

import kotlinx.android.synthetic.main.activity_main.*
import kotlinx.android.parcel.Parcelize
error: unresolved reference 'kotlinx'.
import kotlinx.android.synthetic.main.activity_main.*
       ^^^^^^^
error: unresolved reference 'kotlinx'.
import kotlinx.android.parcel.Parcelize
       ^^^^^^^

Es la salida de kotlinc sin nada más en el classpath. En un proyecto real con corrutinas o con kotlin-parcelize, el paquete kotlinx sí existe, así que el error apunta a la parte siguiente: unresolved reference 'android', debajo de android en el import.

Borra los imports de kotlinx.android.synthetic y cambia el de Parcelize por kotlinx.parcelize.Parcelize, con el plugin kotlin-parcelize en Gradle. Para encontrarlos todos, busca kotlinx.android en el proyecto.

3. Usar el binding antes de inflarlo

Si declaras el binding con lateinit y lo usas antes de asignarlo, por ejemplo al mover código de sitio en onCreate(), la app se cierra al abrir la pantalla. Reproducido en Kotlin puro, con una clase que hace de binding:

class Binding(val boton: String)

class Pantalla {
    private lateinit var binding: Binding

    fun onCreate() {
        println(binding.boton) // se usa antes de inflarlo
        binding = Binding("boton")
    }
}

fun main() = Pantalla().onCreate()
Exception in thread "main" kotlin.UninitializedPropertyAccessException: lateinit property binding has not been initialized
	at Pantalla.onCreate(Lateinit.kt:7)

El orden en la activity es siempre el mismo: inflate, setContentView(binding.root) y, después, todo lo demás.

4. Olvidar onDestroyView() en los fragments

Con View Binding eres tú quien guarda la referencia a las vistas, y si no la vacías en onDestroyView(), el fragment retiene una vista que ya no se muestra. Es el patrón del apartado «Los fragments: limpia el binding», más arriba.

5. Un campo de tipo View en lugar de TextView

Si un mismo id es un TextView en un layout y un EditText en su variante horizontal, la documentación explica que View Binding genera el campo como View y tendrías que convertirlo a mano. Se arregla con tools:viewBindingType="TextView" en la variante. Y si un id solo existe en algunas variantes, el campo es nulable: Kotlin te obliga a comprobarlo, que es justo lo que las extensiones no hacían.

Cuándo no usar View Binding

  • En pantallas nuevas con Compose. Si la pantalla es de Compose, no hay layout que enlazar. View Binding es para el código con vistas XML que ya existe o que vas a seguir manteniendo.
  • Si necesitas expresiones en el XML. View Binding no admite variables ni expresiones en el layout ni el enlace en los dos sentidos. Para eso está Data Binding, a costa de compilar más despacio.
  • Para seguir con las extensiones «un poco más». No hay versión de Kotlin actual que las admita. Quedarte en Kotlin 1.7 para no migrar te deja sin las correcciones y mejoras de varios años; migrar pantalla a pantalla es más seguro.

Ejercicio de cinco minutos

  1. Busca en tu proyecto kotlinx.android. Apunta cuántas pantallas usan imports sintéticos y si alguna usa el Parcelize antiguo.
  2. Elige la pantalla más pequeña y pasa sus layouts e ids por claseBinding y campoBinding para tener la lista de nombres nuevos.
  3. Añade una comprobación para un layout con un número (item_lista_2.xml) y mira si la función da lo que esperas. Si no lo tienes claro, activa View Binding en un proyecto de prueba y compara con la clase que genera.

Para ver qué más puedes hacer con un botón, mira Eventos y clicks en Android. Y si el Toast del ejemplo te interesa, está explicado en Toast y Snackbar en Android.

Fuentes

Consultadas el 11 de noviembre de 2026.

  • Android Developers, Migrate from Kotlin synthetics to Jetpack view binding: Kotlin Android Extensions está obsoleto, pasos de la migración y paso a kotlin-parcelize si se usa Parcelable.
  • Android Developers, View binding: buildFeatures { viewBinding = true }, nombre de la clase en PascalCase con Binding, ids en camelCase (user_bio), uso en activities y fragments con limpieza en onDestroyView(), campos nulables y tools:viewBindingType, y diferencias con Data Binding.
  • Android Developers, Parcelable implementation generator: plugin kotlin-parcelize e import kotlinx.parcelize.Parcelize.
  • Android Developers, Compose BOM (BOM 2026.09.00) y notas de versión de Compose UI (1.12.1, 9 de septiembre de 2026).
  • Android Developers Blog, The future of Kotlin Android Extensions (23 de noviembre de 2020): el periodo de obsolescencia empieza con Kotlin 1.4.20; una nota posterior sitúa la retirada en Kotlin 1.8.
  • Kotlin, historial de versiones: fechas de 1.4.20, 1.8.0, 2.4.0 y 2.4.21.
  • Comprobaciones del 11 de noviembre de 2026: se ha inspeccionado el plugin de Gradle de Kotlin (kotlin-gradle-plugin) publicado en Maven Central. Las versiones 1.7.22 a 2.3.21 incluyen el plugin kotlin-android-extensions; en 1.7.22 su mensaje es un aviso de obsolescencia; en 1.8.0, 2.0.0, 2.1.0 y 2.1.10, el error «no longer supported» con la guía de migración; en 2.1.20, 2.2.0 y 2.2.10, el diagnóstico AndroidExtensionPluginRemoval con «will be removed in future release», y en 2.2.20, 2.2.21, 2.3.0 y 2.3.21, con «was removed». Desde 2.4.0 ya no lo incluye. Con Gradle 9.8.2 y el plugin de Kotlin 2.4.21 (imagen Docker gradle:jdk21), aplicar el plugin da los dos errores «not found» del artículo. La función de nombres, los imports sintéticos sin plugin (también con kotlinx-coroutines-core-jvm 1.11.0 en el classpath, que da el error en android) y el lateinit sin inicializar se han compilado y ejecutado con kotlinc-jvm 2.4.21 y kotlin-test 2.4.21 sobre OpenJDK 25.0.5 (imagen eclipse-temurin:25).
  • El código de Android (activity, fragment y Gradle de Android) está [SIN EJECUTAR]: sigue la documentación oficial de View Binding.