📅 Historia y Orígenes de Android
Android no nació como sistema operativo para móviles — nació para cámaras digitales. En 2003, Andy Rubin, Rich Miner, Nick Sears y Chris White fundaron Android Inc. con ese objetivo. Pivotaron rápidamente al mercado de smartphones, y en 2005 Google adquirió la compañía por ~50 millones de dólares.
El primer dispositivo Android llegó en 2008: el HTC Dream (T-Mobile G1). Desde entonces, Android ha crecido hasta convertirse en el sistema operativo más usado del planeta.
En 2007 Google anunció la OHA — un consorcio de 80+ empresas (HTC, Samsung, LG, Motorola, Sony, Qualcomm, Intel...) para desarrollar estándares abiertos para móviles. Android se publicó bajo licencia Apache 2.0 — completamente abierto y gratuito.
🏗️ Arquitectura de Android: las 5 capas
Android se organiza como una pila de 5 capas donde cada nivel provee servicios a la capa superior. Entender esta estructura ayuda a saber qué ocurre «por debajo» cuando ejecutamos nuestra app.
Analogía: es como un edificio — el sótano (kernel) sostiene todo, las plantas intermedias ofrecen servicios, y en la última planta (la app) es donde el usuario vive.
Desde Android 5.0 (Lollipop), ART (Android Runtime) reemplazó a Dalvik. ART usa compilación AOT (Ahead-Of-Time, al instalar) + JIT (Just-In-Time, en ejecución). Resultado: apps más rápidas y menor consumo de batería.
📱 Versiones de Android y API Levels
Cada versión de Android tiene un API Level — un número que identifica qué funcionalidades están disponibles. Cuando desarrollas, defines un minSdkVersion (mínimo compatible) y un targetSdkVersion (versión objetivo).
| Versión | API | Nombre | Año | Hito clave |
|---|---|---|---|---|
| 5.0 | 21 | Lollipop | 2014 | Material Design, ART reemplaza Dalvik |
| 6.0 | 23 | Marshmallow | 2015 | Permisos en runtime, USB-C |
| 8.0 | 26 | Oreo | 2017 | Picture-in-Picture, Project Treble |
| 10 | 29 | — | 2019 | Modo oscuro oficial, 5G nativo |
| 12 | 31 | Material You | 2021 | Colores dinámicos desde fondo pantalla |
| 14 | 34 | — | 2023 | Personalización avanzada, rendimiento |
| 15 | 35 | — | 2024 | IA integrada, audio espacial |
En 2024: Android 14 ~30% · Android 13 ~25% · Android 12 ~18% · Android 11 o inferior ~27%. Esto significa que si fijas minSdkVersion 29, excluyes a ~27% de usuarios pero garantizas funciones modernas. Hay que equilibrar cobertura y funcionalidad.
🌐 El Ecosistema Android
¿Sabes por qué los teléfonos Huawei actuales no tienen Google Play? ¿Qué usa Huawei en su lugar y qué implicaciones tiene para los desarrolladores?
Android nació en 2003, adquirido por Google en 2005. Arquitectura en 5 capas: Kernel Linux → HAL → ART+Librerías → Framework → Apps. Cada versión tiene un API Level. ~70% cuota global. Ecosistema: Play Store, GMS, AOSP y Android Enterprise.
🛠️ Android Studio: el IDE oficial
Android Studio es el entorno de desarrollo integrado oficial para Android. Está basado en IntelliJ IDEA (JetBrains) y es completamente gratuito. Incluye editor de código, diseñador visual de layouts, emulador, depurador y profiler de rendimiento.
| Componente | Mínimo | Recomendado |
|---|---|---|
| Sistema operativo | Windows 8+, macOS 10.14+, Linux | Windows 10/11, macOS 12+ |
| RAM | 4 GB | 16 GB o más |
| Espacio en disco | 2 GB | 8 GB+ (SSD) |
| Resolución | 1280×800 | 1920×1080+ |
- Descargar desde developer.android.com/studio (versión estable)
- Ejecutar instalador (.exe en Windows, arrastrar a Applications en Mac)
- Seleccionar tipo Standard en la configuración inicial
- Aceptar licencias del SDK y esperar descarga de componentes
- ¡Listo! Crear primer proyecto con la plantilla "Empty Activity"
📦 Configuración del SDK Manager
El SDK Manager (Settings → SDK Manager) gestiona todos los componentes necesarios para compilar y ejecutar apps. Piensa en él como un gestor de herramientas de taller.
| Componente SDK | Descripción |
|---|---|
| Android SDK Platform | Sistema Android para cada versión objetivo (ej. API 34) |
| SDK Build-Tools | Compiladores: aapt, d8, zipalign |
| SDK Platform-Tools | adb (Android Debug Bridge) y fastboot |
| Android Support/AndroidX | Librerías de compatibilidad retrocompatibles |
| Google Repository | Google Play Services y APIs de Google |
📁 Estructura de un Proyecto Android
Todo proyecto Android sigue una estructura estandarizada de directorios. Conocerla bien es fundamental para trabajar de forma eficiente y no perderse entre archivos.
El AndroidManifest.xml — el DNI de la app:
Es el fichero más importante del proyecto. Declara permisos, registra todos los componentes y define la Activity de arranque.
<!-- AndroidManifest.xml — configuración global de la app --> <manifest xmlns:android="http://schemas.android.com/apk/res/android"> <!-- Permisos que la app necesita --> <uses-permission android:name="android.permission.INTERNET"/> <uses-permission android:name="android.permission.CAMERA"/> <application android:icon="@mipmap/ic_launcher" android:theme="@style/Theme.MiApp"> <!-- Registrar la Activity principal --> <activity android:name=".MainActivity" android:exported="true"> <intent-filter> <action android:name="android.intent.action.MAIN"/> <category android:name="android.intent.category.LAUNCHER"/> </intent-filter> </activity> </application> </manifest>
Olvidar registrar un componente (Activity, Service, BroadcastReceiver) en el AndroidManifest.xml. El resultado es un crash inmediato al intentar usar ese componente. Todo componente nuevo debe declararse en el Manifest.
📲 Emuladores (AVD) y ADB
El AVD Manager (Android Virtual Device) permite crear dispositivos virtuales para probar sin hardware físico. ADB (Android Debug Bridge) es la herramienta de línea de comandos para comunicarse con el dispositivo.
✅ Crear AVD
- Tools → Device Manager → Create Device
- Seleccionar hardware (Pixel 7...)
- Elegir imagen del sistema (API 34)
- Configurar RAM y almacenamiento
⚠️ Limitaciones del emulador
- Rendimiento inferior al real
- NFC y BT limitados
- Consume recursos del PC
- Siempre probar en real antes de publicar
Activar depuración en dispositivo real:
Ajustes → Acerca del teléfono → pulsar «Número de compilación» 7 veces → aparece «Opciones de desarrollador» → activar Depuración USB → conectar por USB y aceptar el permiso en el teléfono.
Comandos ADB esenciales:
# Gestión de dispositivos adb devices # Listar dispositivos conectados adb install app.apk # Instalar un APK adb uninstall com.paquete.app # Desinstalar una app # Depuración adb logcat # Ver logs en tiempo real adb shell # Abrir shell remota en el dispositivo # Transferencia de archivos adb pull /sdcard/archivo local/ # Dispositivo → PC adb push archivo.txt /sdcard/ # PC → Dispositivo adb reboot # Reiniciar el dispositivo # WiFi Debugging (Android 11+) adb pair IP:PUERTO # Emparejar por WiFi adb connect IP:PUERTO # Conectar vía WiFi
¿Para qué sirve adb logcat? ¿En qué situación te sería útil durante el desarrollo de una app? ¿Qué diferencia hay entre depurar en emulador y en dispositivo real?
Android Studio (IntelliJ-based, gratuito) es el IDE oficial. SDK Manager gestiona versiones y herramientas. La estructura del proyecto tiene java/ (código) + res/ (recursos) + AndroidManifest.xml (registro central). AVD para emuladores. ADB para comunicarse con el dispositivo vía línea de comandos.
🧱 Los 4 Componentes Principales de Android
Android define cuatro tipos fundamentales de componentes. Son los bloques de construcción de cualquier app. Todos deben declararse en el AndroidManifest.xml.
// 1. ACTIVITY — pantalla con UI class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) } } // 2. SERVICE — trabajo en segundo plano class MyService : Service() { override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { // Tarea en segundo plano aquí return START_STICKY // Se reinicia si el sistema lo mata } override fun onBind(intent: Intent?): IBinder? = null } // 3. BROADCASTRECEIVER — escucha eventos del sistema class BatteryReceiver : BroadcastReceiver() { override fun onReceive(context: Context, intent: Intent) { if (intent.action == Intent.ACTION_BATTERY_LOW) { // Reaccionar cuando la batería está baja } } }
Piensa en una empresa: Activity = recepción (cara visible al cliente). Service = almacén (trabaja sin que el cliente lo vea). BroadcastReceiver = sistema de alarmas (reacciona a eventos). ContentProvider = archivo compartido (datos accesibles por todos los departamentos).
🔄 Ciclo de Vida de un Activity
Una Activity no existe solo en dos estados (existe/no existe) — pasa por varios estados a lo largo de su vida. Gestionar este ciclo correctamente evita pérdidas de datos, consumo innecesario de batería y crashes.
| Método | Qué hacer aquí |
|---|---|
| onCreate() | setContentView(), vincular vistas, inicializar |
| onStart() | Preparar la interfaz de usuario |
| onResume() | Iniciar animaciones, cámara, listeners |
| onPause() | Pausar animaciones, guardar estado temporal |
| onStop() | Liberar recursos pesados |
| onDestroy() | Limpieza final de todos los recursos |
En onPause() y onStop() libera recursos que consuman CPU o memoria (cámara, GPS, sensores). En onCreate() y onResume() vuélvelos a inicializar. Nunca hagas operaciones lentas en onCreate() — bloquea el arranque y el sistema considera que la app no responde.
✉️ Intents: comunicación entre componentes
Los Intents son el mecanismo de mensajería de Android. Permiten que componentes se comuniquen, navegar entre pantallas y solicitar acciones al sistema.
Especifica exactamente el componente destino. Para navegar dentro de tu propia app.
// Navegar a SecondActivity val intent = Intent(this, SecondActivity::class.java) intent.putExtra("KEY", "valor") startActivity(intent) // Recibir en destino val v = intent.getStringExtra("KEY")
Declara la acción, el sistema elige la app. Para usar funciones del dispositivo o de otras apps.
// Abrir URL startActivity(Intent( Intent.ACTION_VIEW, Uri.parse("https://ejemplo.com"))) // Llamar por teléfono startActivity(Intent( Intent.ACTION_DIAL, Uri.parse("tel:+34600123456"))) // Compartir texto val i = Intent(Intent.ACTION_SEND) i.type = "text/plain" i.putExtra(Intent.EXTRA_TEXT, "Texto") startActivity(Intent.createChooser(i, "Compartir"))
🧩 Fragments: UI modular y reutilizable
Un Fragment es una porción de UI reutilizable que vive dentro de una Activity. Permite construir interfaces adaptables — un teléfono puede mostrar un Fragment a la vez, mientras una tablet muestra dos simultáneamente.
Analogía: si la Activity es una habitación, los Fragments son los muebles — puedes moverlos, reemplazarlos o quitarlos según necesites.
// Añadir o reemplazar un Fragment dinámicamente supportFragmentManager.beginTransaction() .replace(R.id.fragment_container, MiFragment()) .addToBackStack(null) // Permite volver con el botón Back .commit()
¿Por qué una Activity tiene su propio ciclo de vida y un Fragment también tiene el suyo? ¿Qué ocurre con el Fragment cuando la Activity en la que vive se pausa?
4 componentes: Activity (UI), Service (background), BroadcastReceiver (eventos), ContentProvider (datos). Todos en el Manifest. Ciclo de vida de Activity: onCreate → onStart → onResume ↔ onPause → onStop → onDestroy. Intents explícitos (dentro de la app) vs implícitos (sistema). Fragments para UI modular.
📐 Layouts y ViewGroups
En Android, la interfaz se construye con Views (elementos básicos: botón, texto, imagen) organizadas dentro de ViewGroups (contenedores). Un layout es un ViewGroup que define cómo se colocan sus hijos.
<!-- ConstraintLayout — el más recomendado --> <androidx.constraintlayout.widget.ConstraintLayout android:layout_width="match_parent" android:layout_height="match_parent"> <TextView android:id="@+id/tvTitulo" android:text="@string/titulo" app:layout_constraintTop_toTopOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintEnd_toEndOf="parent" android:layout_marginTop="16dp"/> <Button android:id="@+id/btnAccion" android:text="Aceptar" app:layout_constraintTop_toBottomOf="@id/tvTitulo" app:layout_constraintStart_toStartOf="parent" app:layout_constraintEnd_toEndOf="parent"/> </androidx.constraintlayout.widget.ConstraintLayout>
Anidar múltiples LinearLayouts degrada el rendimiento porque Android tiene que calcular la posición en múltiples pasadas. ConstraintLayout resuelve todo en una sola pasada de medición, haciendo la UI más fluida.
🎛️ Controles de UI Básicos
| Control | Atributos clave | Uso típico |
|---|---|---|
| TextView | text, textSize (sp), textColor, textStyle | Mostrar texto estático o dinámico |
| EditText | hint, inputType, maxLines | Entrada de texto del usuario |
| Button | text, onClick, style Material | Acción principal de la pantalla |
| ImageView | src, scaleType (centerCrop, fitCenter) | Imágenes e iconos |
| CheckBox | checked, text, OnCheckedChangeListener | Selección múltiple de opciones |
| RadioButton/Group | orientation, getCheckedRadioButtonId() | Selección exclusiva entre opciones |
| Switch | checked, OnCheckedChangeListener | Activar/desactivar funciones |
| Spinner | entries (array), OnItemSelectedListener | Lista desplegable de opciones |
| RecyclerView | adapter, layoutManager | Listas y cuadrículas de gran volumen |
El inputType determina qué teclado muestra Android. textEmailAddress muestra teclado con @, textPassword oculta los caracteres, number muestra solo números, phone muestra el marcador telefónico. ¡Usarlo correctamente mejora mucho la UX!
🎨 Material Design 3 (Material You)
Material Design 3 es el sistema de diseño de Google: componentes, colores, tipografía y movimiento. Proporciona coherencia visual entre todas las apps de Android y facilita el cumplimiento de las guías de accesibilidad.
Usar dimensiones en píxeles (px) fijos en lugar de dp para layouts y sp para textos. Los px no escalan con la densidad de pantalla — en un móvil de alta resolución un botón de 100px quedará microscópico. Usar siempre dp/sp.
¿Qué diferencia hay entre dp y sp? ¿Por qué el texto usa sp en lugar de dp? Pista: piensa en la configuración de accesibilidad "Tamaño de texto" de tu móvil.
ConstraintLayout recomendado para layouts complejos. View = elemento (Button, TextView). ViewGroup = contenedor (LinearLayout, ConstraintLayout). Controles básicos: TextView, EditText, Button, RecyclerView. Material Design 3 proporciona el lenguaje visual de Android. Siempre dp para layouts, sp para textos.
📂 El directorio res/: todo lo que no es código
En Android, todo lo que no es lógica de programación va en la carpeta res/: textos, colores, dimensiones, imágenes, layouts, animaciones... Esta separación facilita la localización y la adaptación a diferentes dispositivos.
// Acceder a recursos desde código Kotlin val texto = getString(R.string.app_name) val color = getColor(R.color.primary) val margen = resources.getDimensionPixelSize(R.dimen.margin_standard) val icono = getDrawable(R.drawable.ic_logo)
📝 strings.xml — Textos de la app
Todos los textos visibles deben estar en strings.xml, nunca escritos directamente en el código o el layout. Esto permite traducir la app a otro idioma simplemente creando una nueva carpeta de recursos.
<!-- res/values/strings.xml --> <resources> <string name="app_name">Mi Aplicación</string> <!-- String con parámetro --> <string name="hello">¡Hola, %1$s!</string> <!-- Array de strings --> <string-array name="paises"> <item>España</item> <item>México</item> </string-array> <!-- Plurales (1 mensaje / 5 mensajes) --> <plurals name="num_mensajes"> <item quantity="one">%d mensaje</item> <item quantity="other">%d mensajes</item> </plurals> </resources>
🎨 colors.xml, dimens.xml y themes.xml
<!-- colors.xml — paleta de colores --> <resources> <color name="primary">#6200EE</color> <color name="secondary">#03DAC6</color> <!-- Transparencia: formato ARGB (80 = 50% opacidad) --> <color name="semi_transparent">#80000000</color> </resources> <!-- dimens.xml — dimensiones en dp y sp --> <resources> <dimen name="margin_small">8dp</dimen> <dimen name="margin_standard">16dp</dimen> <dimen name="text_size_title">18sp</dimen> <!-- sp para textos --> <dimen name="button_height">48dp</dimen> <!-- dp para layouts --> </resources> <!-- themes.xml — aspecto visual global --> <style name="Theme.MiApp" parent="Theme.MaterialComponents.DayNight.DarkActionBar"> <item name="colorPrimary">@color/primary</item> <item name="colorSecondary">@color/secondary</item> </style>
dp (density-independent pixels) — para tamaños de layout. 1dp = mismo tamaño visual en todas las pantallas independientemente de la resolución.
sp (scale-independent pixels) — para tamaños de texto. Como los dp, pero además respeta la configuración de accesibilidad del usuario (tamaño de fuente aumentado).
🌍 Internacionalización (i18n) y Drawables
Android selecciona automáticamente los recursos según el idioma del dispositivo. Solo hay que duplicar el strings.xml en cada carpeta con las traducciones.
<!-- Vector Drawable — icono escalable a cualquier densidad --> <vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="24" android:viewportHeight="24"> <path android:fillColor="@color/primary" android:pathData="M9,16.17L4.83,12l-1.42,1.41L9,19 21,7l-1.41,-1.41z"/> </vector> <!-- Shape Drawable — fondo redondeado sin imagen bitmap --> <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle"> <solid android:color="@color/primary"/> <corners android:radius="8dp"/> <padding android:left="16dp" android:top="8dp" android:right="16dp" android:bottom="8dp"/> </shape>
Las imágenes bitmap (PNG, JPG) necesitan versiones para cada densidad de pantalla (mdpi, hdpi, xhdpi, xxhdpi...). Los Vector Drawables son archivos XML que describen formas matemáticas — escalan perfectamente a cualquier tamaño con un solo archivo.
¿Por qué es importante no escribir strings directamente en el código XML del layout? Piensa en una app que quieres lanzar en España y en México — ¿qué pasos tendrías que dar para que esté en español de ambos países?
Todo lo no-código va en res/. strings.xml para textos (nunca hardcoded). colors.xml para colores. dimens.xml: dp para layouts, sp para textos. themes.xml para apariencia global. i18n con carpetas values-XX/. Vector Drawables para iconos escalables.
Ejercicios en orden creciente de complejidad. Pueden usarse en clase o como tarea.
💬 Reflexiones rápidas para clase
Con el Tema 2 dominas los cimientos necesarios para construir cualquier app Android:
Android es el sistema operativo más usado del planeta. Comprenderlo a nivel arquitectónico, dominar su entorno de desarrollo y conocer sus bloques fundamentales (componentes, ciclo de vida, recursos) te da la base para construir apps reales que llegan a más de 3.000 millones de personas. El siguiente paso: construir.