Entorno de desarrollo Android con Kotlin en Android Studio

Instalación y configuración de Android Studio

Android Studio es el IDE oficial para desarrollar apps Android con Kotlin. Incluye herramientas para editar código, diseñar interfaces, compilar, depurar y ejecutar en emuladores o dispositivos físicos. Para trabajar sin fricción, necesitas: Android Studio, un JDK compatible (normalmente incluido), el Android SDK (plataformas y herramientas) y al menos una imagen de sistema para el emulador.

Requisitos recomendados

• RAM: 8 GB mínimo (16 GB recomendado para emulador fluido).
• Espacio: 10–20 GB libres (SDK + imágenes de emulador ocupan bastante).
• Virtualización: activada en BIOS/UEFI (Intel VT-x / AMD-V) para acelerar el emulador.

Instalar Android Studio

1. Descarga Android Studio desde el sitio oficial de Android Developers.
2. Ejecuta el instalador y marca componentes típicos: Android Studio, Android SDK, Android Virtual Device.
3. Al abrir por primera vez, sigue el asistente (Standard suele ser suficiente) para descargar SDKs iniciales.

SDK Manager: plataformas, herramientas y variables útiles

El Android SDK se compone de: (1) Android SDK Platforms (APIs por versión), (2) Build Tools (aapt2, d8, etc.), (3) Platform Tools (adb), y (4) herramientas extra (emulador, cmdline-tools).

Abrir SDK Manager

En Android Studio: Settings/Preferences > Android SDK.

Qué instalar (mínimo práctico)

• SDK Platforms: instala al menos la versión objetivo que usarás (por ejemplo, la más reciente estable) y, si necesitas compatibilidad, una o dos anteriores.
• SDK Tools:
  • Android SDK Platform-Tools (incluye adb).
  • Android SDK Build-Tools.
  • Android Emulator.
  • Android SDK Command-line Tools (latest) (útil para diagnósticos y CI).

Ubicación del SDK

Android Studio gestiona la ruta del SDK. Si alguna herramienta externa la necesita, la encontrarás en el SDK Manager (campo Android SDK Location). En general no es necesario tocar variables de entorno, pero en casos avanzados puedes requerir ANDROID_HOME o ANDROID_SDK_ROOT apuntando a esa carpeta.

Crear y configurar un emulador (AVD)

Un AVD (Android Virtual Device) es un dispositivo virtual con una imagen de sistema (API) y un perfil de hardware (tamaño, RAM, etc.).

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

Crear un AVD paso a paso

1. Ve a Tools > Device Manager.
2. En Virtual, pulsa Create device.
3. Elige un perfil (por ejemplo, Pixel) y pulsa Next.
4. Selecciona una System Image (API). Si no está descargada, pulsa Download.
5. Configura opciones (nombre, orientación, gráficos). Para mejor rendimiento, usa aceleración por hardware si está disponible.
6. Finaliza y pulsa Play para iniciar el emulador.

Consejos de rendimiento del emulador

• Activa virtualización en BIOS/UEFI.
• En Windows, revisa compatibilidad entre Hyper-V y aceleración del emulador según tu configuración.
• Asigna recursos razonables (no excedas la RAM disponible del equipo).

Crear tu primer proyecto en Kotlin

Un proyecto Android se compone de módulos (por ejemplo, app) y archivos de configuración (Gradle) que definen cómo se compila y empaqueta la app.

Pasos para crear el proyecto

1. En Android Studio: New Project.
2. Elige una plantilla: Empty Activity (o equivalente).
3. Configura:
   • Name: nombre de la app.
   • Package name: identificador único (ej. com.tuempresa.tuapp).
   • Language: Kotlin.
   • Minimum SDK: elige según tu público objetivo (a menor, más dispositivos; a mayor, más APIs disponibles).
4. Finaliza y espera la sincronización de Gradle.

Verificar que compila

Cuando el proyecto abra, espera a que termine Gradle Sync. Luego usa Build > Make Project para confirmar que no hay errores de compilación.

Estructura del proyecto: módulos, manifiesto, recursos y Gradle

Módulos

Un proyecto puede tener varios módulos. El más común es app, que produce el APK/AAB. También puedes tener módulos de librería o features dinámicas.

• Proyecto: contenedor global (configuración de Gradle, repositorios, versiones).
• Módulo app: código Kotlin, recursos, manifiesto y configuración específica.

AndroidManifest.xml

El manifiesto describe componentes y capacidades de la app: actividades, permisos, intent-filters, etc. Suele vivir en app/src/main/AndroidManifest.xml.

<manifest package="com.tuempresa.tuapp">    <application        android:label="TuApp">        <activity android:name=".MainActivity">            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>        </activity>    </application></manifest>

En proyectos modernos, parte de esta configuración puede generarse o complementarse desde Gradle, pero el manifiesto sigue siendo central.

Recursos (res)

Los recursos son archivos no Kotlin que Android empaqueta: layouts, strings, imágenes, temas, etc. Se ubican en app/src/main/res. Se accede a ellos mediante IDs generados (por ejemplo, R.string.app_name).

• res/layout/: pantallas (XML) si usas Views.
• res/values/: strings.xml, colors.xml, themes.xml.
• res/drawable/: imágenes y shapes.
• res/mipmap/: iconos de launcher.

Gradle: cómo se construye tu app

Gradle es el sistema de construcción. Define dependencias, versiones, tipos de build (debug/release), y opciones del compilador.

Archivos típicos:

• Gradle del proyecto: configura repositorios y plugins a nivel global.
• Gradle del módulo (app): define namespace, applicationId, minSdk, targetSdk, dependencias, etc.

Ejemplo simplificado (módulo app):

plugins {    id("com.android.application")    kotlin("android")}android {    namespace = "com.tuempresa.tuapp"    compileSdk = 34    defaultConfig {        applicationId = "com.tuempresa.tuapp"        minSdk = 24        targetSdk = 34        versionCode = 1        versionName = "1.0"    }}dependencies {    // Aquí agregas librerías}

Cuando cambias dependencias o versiones, Android Studio suele pedir Sync Now para re-sincronizar el proyecto.

Práctica guiada: ejecutar en emulador

1) Seleccionar el dispositivo

1. Inicia el emulador desde Device Manager (botón Play).
2. En la barra superior de Android Studio, en el selector de dispositivos, elige el emulador activo.

2) Ejecutar la app

1. Pulsa Run (icono de play) o usa Shift + F10 (Windows/Linux) / Control + R (macOS, según keymap).
2. Espera a que Gradle compile y se instale la app.
3. Verifica que se abre la pantalla inicial.

3) Ver logs para depurar

Abre Logcat para ver mensajes y errores. Filtra por el nombre del proceso de tu app o por tu etiqueta de log.

// Ejemplo de log en Kotlin (en una Activity/Fragment)android.util.Log.d("MainActivity", "App iniciada")

Práctica guiada: ejecutar en dispositivo físico

1) Preparar el teléfono

1. Activa Opciones de desarrollador (típicamente tocando varias veces “Número de compilación” en “Acerca del teléfono”).
2. Activa Depuración USB.

2) Conectar y autorizar

1. Conecta el dispositivo por USB.
2. Cuando aparezca el diálogo de autorización de depuración, acepta y marca “Permitir siempre”.

3) Confirmar que Android Studio lo detecta

1. En el selector de dispositivos, elige tu teléfono.
2. Si no aparece, revisa el cable (datos), drivers (Windows) y el modo USB (transferencia de datos).

4) Ejecutar

1. Pulsa Run.
2. Si es la primera vez, puede tardar más por la instalación inicial.

Diagnóstico rápido con ADB

Desde una terminal (si tienes platform-tools disponibles):

adb devices

Deberías ver el dispositivo como device. Si aparece unauthorized, revisa el diálogo de autorización en el teléfono.

Lista de verificación: errores típicos y cómo resolverlos

Instalación y entorno

• Android Studio no abre o va muy lento: verifica RAM disponible, desactiva plugins innecesarios, revisa antivirus/escaneo en tiempo real sobre carpetas de Gradle/SDK.
• Emulador extremadamente lento: confirma virtualización activada; revisa configuración de aceleración; reduce resolución o RAM del AVD.
• No puedo descargar SDKs: revisa proxy/firewall; en Settings > HTTP Proxy configura “No proxy” o el proxy correcto; intenta con otra red.

Gradle Sync y dependencias

• “Gradle sync failed”: abre el panel de errores, identifica si es repositorio, versión de plugin o red; pulsa Sync Now tras corregir.
• Timeout descargando dependencias: revisa conexión; considera habilitar Gradle offline solo si ya tienes caché; prueba invalidar cachés.
• Incompatibilidad de versiones (AGP/Kotlin/Gradle): usa versiones compatibles entre Android Gradle Plugin, Gradle Wrapper y Kotlin; si actualizas uno, revisa los otros.
• “Could not find…”: confirma que el repositorio está configurado (por ejemplo, Maven Central/Google) y que el nombre de la dependencia es correcto.

Compilación y ejecución

• App no instala en emulador/dispositivo: revisa espacio libre; desinstala versiones previas si hay conflicto de firma; intenta Build > Clean Project y luego Rebuild Project.
• “INSTALL_FAILED_VERSION_DOWNGRADE”: incrementa versionCode o desinstala la app existente del dispositivo.
• “INSTALL_FAILED_UPDATE_INCOMPATIBLE”: desinstala la app previa (firmada distinto) del dispositivo.
• Emulador no arranca: borra datos del AVD (Wipe Data), prueba Cold Boot, actualiza Android Emulator en SDK Tools.
• Dispositivo no aparece: cambia cable/puerto; habilita transferencia de datos; reinstala drivers (Windows); ejecuta adb kill-server y adb start-server.
• Se queda en “Installing…”: revisa Logcat y la ventana Run; reinicia ADB; reinicia el dispositivo o el emulador.

Herramientas de recuperación en Android Studio

• File > Invalidate Caches / Restart: útil si el IDE se comporta de forma inconsistente tras cambios o actualizaciones.
• Sync Project with Gradle Files: fuerza relectura de configuración.
• Clean/Rebuild: limpia artefactos y recompila.