Android es un sistema operativo basado en Linux, diseñado principalmente para dispositivos móviles como teléfonos y tabletas, aunque también se utiliza en relojes, televisores, automóviles y otros dispositivos.

Para desarrollar aplicaciones Android se utiliza el Android SDK (Software Development Kit), un conjunto de herramientas, bibliotecas y APIs que permiten crear, compilar, probar y depurar aplicaciones.

De forma simplificada podemos distinguir:

• Android: el sistema operativo que se ejecuta en el dispositivo
• Android SDK: las herramientas y APIs utilizadas para desarrollar aplicaciones
• Android Studio: el entorno de desarrollo utilizado para escribir y gestionar nuestros proyectos

Las aplicaciones Android se ejecutan sobre ART (Android Runtime), el entorno de ejecución utilizado actualmente por Android.

Android Studio es el entorno de desarrollo integrado (IDE) oficial para crear aplicaciones Android. Está basado en IntelliJ IDEA e incorpora las herramientas necesarias para facilitar el desarrollo.

Entre sus principales características se encuentran:

• Editor de código para Kotlin y Java
• Integración con Gradle para compilar los proyectos
• Gestión del Android SDK
• Emulador de dispositivos Android
• Herramientas de depuración
• Diseño y previsualización de interfaces
• Integración con sistemas de control de versiones como Git

Durante el módulo utilizaremos Android Studio, Kotlin y el Android SDK para desarrollar nuestras aplicaciones.

El Android SDK (Software Development Kit) es el conjunto de herramientas, bibliotecas y APIs necesarias para desarrollar aplicaciones para Android.

El SDK incluye, entre otros elementos:

• Las APIs correspondientes a las diferentes versiones de Android
• Herramientas de compilación
• Herramientas para comunicarse con dispositivos Android
• Herramientas de depuración
• Gestión de dispositivos virtuales
• Utilidades utilizadas internamente por Android Studio

Android Studio permite instalar y gestionar estos componentes mediante el SDK Manager. Por ejemplo, un equipo puede tener instaladas diferentes versiones del SDK:

Android SDK
|
+-- Android API 35
+-- Android API 36
+-- Android API 37
|
+-- Build Tools
|
+-- Platform Tools
    |
    +-- adb

No es necesario instalar todas las versiones disponibles. Normalmente se instalan únicamente aquellas que van a utilizarse para desarrollar y probar las aplicaciones.

Android ha tenido numerosas versiones desde su aparición. Cada versión incorpora nuevas funcionalidades y modificaciones en el sistema operativo. Para identificar las capacidades disponibles en cada versión, Android utiliza un número denominado API Level.

Por ejemplo:

El nivel de API resulta especialmente importante durante el desarrollo, ya que determina qué funcionalidades de Android podemos utilizar.

En los proyectos encontraremos principalmente tres valores dentro del fichero app/build.gradle.kts

minSdk = 24
targetSdk = 36
compileSdk = 37

Por ejemplo:

minSdk = 24
targetSdk = 36
compileSdk = 37

significa que la aplicación:

• puede instalarse desde API 24
• está preparada principalmente para el comportamiento de API 36
• puede utilizar las APIs disponibles durante la compilación con API 37

Cuando creamos un proyecto nuevo en Android Studio se genera automáticamente una estructura de directorios y archivos. Una versión simplificada podría ser:

MiAplicacion
|
+-- app
|   |
|   +-- manifests
|   |   |
|   |   +-- AndroidManifest.xml
|   |
|   +-- kotlin
|   |   |
|   |   +-- MainActivity.kt
|   |
|   +-- res
|       |
|       +-- drawable
|       +-- mipmap
|       +-- values
|
+-- Gradle Scripts

Algunos de sus elementos más importantes son:

Vista Android en el IDE

Los proyectos Android utilizan Gradle como sistema de compilación. Gradle se encarga, entre otras tareas, de:

• Compilar el código
• Gestionar las dependencias
• Procesar los recursos de la aplicación
• Ejecutar pruebas
• Generar los archivos instalables de la aplicación

Por ejemplo, si nuestra aplicación necesita utilizar una determinada librería, Gradle puede descargarla automáticamente. En proyectos actuales es habitual encontrar dependencias definidas mediante un catálogo de versiones:

implementation(libs.androidx.core.ktx)
implementation(libs.androidx.activity.compose)

Las versiones correspondientes pueden encontrarse en:

gradle/libs.versions.toml

Una aplicación Android necesita ejecutarse sobre un dispositivo Android. Tenemos principalmente dos posibilidades:

• Emulador
• Dispositivo físico

Ambas serán configuradas desde el Device Manager de Android Studio.

El emulador es capaz de simular diferentes dispositivos Android. Permite seleccionar características como:

• Tamaño de pantalla
• Resolución
• Versión de Android
• Cantidad de memoria
• Tipo de dispositivo

Su principal ventaja es que permite probar rápidamente una aplicación utilizando diferentes configuraciones. Sin embargo, el emulador puede consumir una cantidad considerable de memoria y recursos del ordenador.

Por otro lado, si tenemos un dispositivo físico Android también podemos ejecutar directamente la aplicación.

Para hacerlo será necesario activar las Opciones de desarrollador y la Depuración USB o Depuración Wifi en nuestro dispositivo. Después podremos conectar el dispositivo al ordenador ejecutar directamente la aplicación desde Android Studio.

Una aplicación Android está formada por diferentes componentes que trabajan conjuntamente. Algunos se encargan de mostrar la interfaz, otros de gestionar datos, ejecutar tareas en segundo plano o comunicarse con otras aplicaciones.

En las primeras aplicaciones nos centraremos principalmente en las Activities, los recursos y el archivo AndroidManifest.xml.

Una Activity representa normalmente una pantalla de una aplicación Android. Por ejemplo, una aplicación podría tener:

Pantalla de inicio     -> MainActivity
Pantalla de ajustes    -> SettingsActivity
Pantalla de detalle    -> DetailActivity

En un proyecto básico creado con Android Studio suele existir inicialmente una clase:

MainActivity.kt

En un proyecto con Jetpack Compose podemos encontrar algo similar a:

class MainActivity : ComponentActivity() {
 
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
 
    setContent {
        MiAplicacion()
    }
}
 
}

El método onCreate() se ejecuta cuando se crea la Activity. Mediante setContent indicamos la interfaz que se mostrará utilizando Jetpack Compose.

setContent {
    MiAplicacion()
}

Una Activity pasa por diferentes estados durante su ejecución: https:// developer.android.com

Por ejemplo:

Se crea
  |
  V
Se muestra
  |
  V
El usuario interactúa
  |
  V
Pasa a segundo plano
  |
  V
Puede destruirse

Android dispone de diferentes métodos asociados a estos cambios:

No siempre será necesario utilizar todos estos métodos, pero es importante comprender que Android controla el ciclo de vida de las pantallas.

El archivo AndroidManifest.xml contiene información importante sobre la aplicación. Entre otras cosas puede indicar:

• Las Activities disponibles
• La Activity que se inicia al abrir la aplicación
• Los permisos necesarios
• Características generales de la aplicación

Por ejemplo:

<activity
    android:name=".MainActivity"
    android:exported="true">
</activity>

Android permite separar determinados elementos del código fuente mediante el sistema de recursos. Estos recursos se almacenan dentro del directorio app/src/main/res

Algunos directorios habituales son:

Por ejemplo, los textos pueden almacenarse en:

res/values/strings.xml

<string name="app_name">Mi aplicación</string>
<string name="saludo">Hola Android</string>

Separar los textos del código facilita, entre otras cosas, la traducción de las aplicaciones a distintos idiomas.

El Context representa el entorno desde el que se está ejecutando una parte de la aplicación. Permite acceder a diferentes recursos y servicios del sistema Android. Por ejemplo, puede utilizarse para:

• Acceder a recursos
• Iniciar otras Activities
• Acceder a servicios del sistema
• Mostrar determinados mensajes

Android Studio incluye Logcat, una herramienta que permite visualizar mensajes generados por la aplicación y por el sistema Android. Podemos escribir nuestros propios mensajes utilizando:

Log.d("MI_APP", "Aplicación iniciada")

Esto resulta muy útil para comprobar qué está ocurriendo durante la ejecución y localizar errores.

Existen dos grandes formas de construir interfaces en Android:

• Views y XML, sistema tradicional de Android
• Jetpack Compose, sistema moderno de interfaces declarativas

Durante el módulo utilizaremos principalmente Jetpack Compose. Con Compose las interfaces se construyen mediante funciones en lenguaje Kotlin. Es el sistema oficial de Google para el diseño de interfaces.

Las funciones que forman parte de la interfaz se marcan con la anotación:

@Composable

Por ejemplo:

@Composable
fun Saludo() {
    Text("Hola Android")
}

Una función @Composable puede llamar a otras funciones @Composable para construir interfaces más complejas.

Por ejemplo:

@Composable
fun PantallaPrincipal() {
    Column {
        Text("Bienvenido")
        Text("Mi primera aplicación")
    }
}

Desde la Activity podemos indicar qué interfaz queremos mostrar utilizando:

setContent {
    PantallaPrincipal()
}

Un ejemplo completo sería:

class MainActivity : ComponentActivity() {
 
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
 
    setContent {
        PantallaPrincipal()
    }
}
 
}

Compose incluye numerosos componentes para construir interfaces. Algunos de los más utilizados al principio son:

Por ejemplo:

@Composable
fun Ejemplo() {
   Text("Nombre")
   Button(
      onClick = {
        // Acción al pulsar
      }
   ) {
    Text("Aceptar")
   }
}

Compose permite organizar los componentes mediante distintos contenedores. Los principales son:

Ejemplo:

@Composable
fun DatosUsuario() {
 
Column {
    Text("Nombre: Ana")
    Text("Edad: 22")
}
 
}

También podemos combinar diferentes contenedores:

@Composable
fun FichaUsuario() {
 
Column {
    Text("Usuario")
 
    Row {
        Text("Ana")
        Text("22 años")
    }
}
 
}

Modifier se utiliza para modificar el aspecto, tamaño o posición de los componentes. Por ejemplo:

Text(
    text = "Hola Android",
    modifier = Modifier.padding(16.dp)
)

También podemos encadenar varios modificadores:

Button(
    onClick = { },
    modifier = Modifier
        .fillMaxWidth()
        .padding(16.dp)
) {
    Text("Aceptar")
}

Algunos modificadores habituales son:

• padding()
• fillMaxWidth()
• fillMaxSize()
• width()
• height()

Jetpack Compose utiliza habitualmente componentes basados en Material Design. Por ejemplo:

Button(
    onClick = { }
) {
    Text("Guardar")
}

o:

TextField(
    value = "",
    onValueChange = { },
    label = {
        Text("Nombre")
    }
)

Estos componentes ya incluyen comportamientos y estilos preparados para aplicaciones Android modernas.

Android Studio permite previsualizar componentes Compose sin ejecutar completamente la aplicación. Para ello se utiliza la anotación:

@Preview

Por ejemplo:

@Preview(showBackground = true)
@Composable
fun PantallaPreview() {
    PantallaPrincipal()
}

Esto permite comprobar rápidamente cómo se verá una parte de la interfaz.

Una de las ventajas de Compose es que podemos dividir una interfaz en funciones pequeñas y reutilizables. Por ejemplo:

@Composable
fun Titulo(texto: String) {
    Text(texto)
}

Podemos reutilizarla varias veces:

@Composable
fun Pantalla() {
 
Column {
    Titulo("Usuarios")
    Titulo("Configuración")
}
 
}

Esto facilita mantener el código organizado y evita repetir elementos.

© 2026 Fernando Valdeón