Javier Carrasco on Documentación

Tema 1A. Kotlin para Android — Repaso acelerado

Mon, 01 Jan 0001 00:00:00 +0000

Tema 1A. Kotlin para Android — Repaso acelerado

Información del tema

Bloque: B1 — Fundamentos: Kotlin, Compose y entorno Android
Duración aproximada: 4 horas

Resultados de Aprendizaje

RA1 — Aplica tecnologías de desarrollo para dispositivos móviles evaluando sus características y capacidades.

Criterios de Evaluación

Código	Criterio
RA1-b	Se han identificado las tecnologías de desarrollo de aplicaciones para dispositivos móviles.
RA1-f	Se ha analizado la estructura de aplicaciones existentes para dispositivos móviles identificando las clases utilizadas.
RA1-g	Se han realizado modificaciones sobre aplicaciones existentes.

Introducción#

Kotlin es el lenguaje oficial de Android desde 2017 y el único recomendado por Google para el desarrollo de aplicaciones modernas con Jetpack Compose. Esta sección asume que ya conoces los fundamentos de programación orientada a objetos, idealmente en Java, y se centra en los aspectos de Kotlin que son distintos, más potentes o especialmente relevantes para el desarrollo Android.

Tema 2. Arquitectura MVVM y ViewModel

Mon, 01 Jan 0001 00:00:00 +0000

Tema 2. Arquitectura MVVM y ViewModel

Información del tema

Bloque: B2 — Arquitectura MVVM y desarrollo de aplicaciones Android
Duración aproximada: 14 horas

Resultados de Aprendizaje

RA2 — Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.

Criterios de Evaluación

Código	Criterio
RA2-a	Se ha generado la estructura de clases necesaria para la aplicación.
RA2-b	Se han analizado y utilizado las clases que modelan ventanas, menús, alertas y controles para el desarrollo de aplicaciones gráficas sencillas.
RA2-g	Se han realizado pruebas de interacción usuario-aplicación para optimizar las aplicaciones desarrolladas a partir de emuladores.
RA2-i	Se han documentado los procesos necesarios para el desarrollo de las aplicaciones.

Dependencias necesarias#

 1// build.gradle.kts (app) — añadir a las del Bloque 1
 2dependencies {
 3    // ViewModel y Lifecycle
 4    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.10.0")
 5    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.10.0")
 6
 7    // Corrutinas
 8    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2")
 9
10    // Testing
11    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
12}

Todos los artefactos lifecycle-* deben compartir la misma versión. Consulta la página de releases de Lifecycle para verificar la última versión estable antes de iniciar un nuevo proyecto.

Tema 4. ROOM: Persistencia local

Mon, 01 Jan 0001 00:00:00 +0000

Tema 4. ROOM: Persistencia local

Información del tema

Bloque: B3 — Persistencia y comunicación: ROOM + Retrofit2
Duración aproximada: 12 horas

Resultados de Aprendizaje

RA2 — Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.
RA3 — Desarrolla programas que integran contenidos multimedia analizando y empleando las tecnologías y librerías específicas.

Criterios de Evaluación

Código	Criterio
RA2-a	Se ha generado la estructura de clases necesaria para la aplicación.
RA2-b	Se han analizado y utilizado las clases que modelan ventanas, menús, alertas y controles.
RA2-f	Se han almacenado y recuperado datos utilizando algún mecanismo de persistencia.
RA2-g	Se han realizado pruebas de interacción usuario-aplicación para optimizar las aplicaciones desarrolladas.
RA2-i	Se han documentado los procesos necesarios para el desarrollo de las aplicaciones.
RA3-c	Se han utilizado clases para la conversión de datos multimedia de un formato a otro.
RA3-d	Se han utilizado clases para procesar datos multimedia.
RA3-e	Se han utilizado clases para el control de eventos, tipos de media y excepciones, entre otros.
RA3-h	Se han depurado y documentado los programas desarrollados.

Dependencias necesarias#

Room utiliza KSP (Kotlin Symbol Processing) como procesador de anotaciones para generar código en tiempo de compilación. A partir de Kotlin 2.0, KAPT queda obsoleto para Room; siempre se debe usar KSP.

Tema 7. Multimedia: Cámara, Galería, Audio y Vídeo

Mon, 01 Jan 0001 00:00:00 +0000

Tema 7. Multimedia: Cámara, Galería, Audio y Vídeo#

Información del tema

Bloque: B4 — Multimedia en Android
Duración aproximada: 9 horas

Resultados de Aprendizaje

RA3 — Desarrolla programas que integran contenidos multimedia analizando y empleando las tecnologías y librerías específicas.

Criterios de Evaluación

Código	Criterio
RA3-a	Se han utilizado las herramientas y entornos de desarrollo para aplicaciones multimedia.
RA3-b	Se han analizado las herramientas disponibles para el tratamiento de imágenes y vídeo.
RA3-c	Se han incorporado procedimientos para la captura de imágenes y grabación de vídeo.
RA3-d	Se han utilizado clases para la reproducción de audio y vídeo.
RA3-e	Se han gestionado los permisos de acceso al hardware multimedia del dispositivo.

Dependencias necesarias#

 1// build.gradle.kts (módulo app)
 2dependencies {
 3    // ── CameraX ───────────────────────────────────────────────────────────────
 4    val cameraxVersion = "1.4.2"
 5    implementation("androidx.camera:camera-core:$cameraxVersion")
 6    implementation("androidx.camera:camera-camera2:$cameraxVersion")    // backend Camera2
 7    implementation("androidx.camera:camera-lifecycle:$cameraxVersion")  // integración con Lifecycle
 8    implementation("androidx.camera:camera-view:$cameraxVersion")       // PreviewView
 9    implementation("androidx.camera:camera-extensions:$cameraxVersion") // HDR, Bokeh, etc. (opcional)
10
11    // ── Media3 / ExoPlayer (reproducción de audio y vídeo) ───────────────────
12    val media3Version = "1.5.1"
13    implementation("androidx.media3:media3-exoplayer:$media3Version")
14    implementation("androidx.media3:media3-ui:$media3Version")          // PlayerView
15    implementation("androidx.media3:media3-common:$media3Version")
16
17    // ── Coil (ya incluido en B3, necesario para mostrar imágenes de la galería) ──
18    // io.coil-kt.coil3:coil-compose:3.2.0
19}

Permisos en AndroidManifest.xml:

Tema 9. Introducción a LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Tema 9. Introducción a LibGDX

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 3 horas

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

Criterios de Evaluación

Código	Criterio
RA4-a	Se han identificado los elementos que componen la arquitectura de un juego 2D y 3D.
RA4-b	Se han analizado los componentes de un motor de juegos.
RA4-c	Se han analizado entornos de desarrollo de juegos.
RA4-d	Se han analizado diferentes motores de juegos, sus características y funcionalidades.
RA4-e	Se han identificado los bloques funcionales de un juego existente.
RA4-f	Se ha reconocido la representación lógica y espacial de una escena gráfica sobre un juego existente.
RA5-a	Se ha establecido la lógica de un nuevo juego.
RA5-b	Se han creado los objetos necesarios para el juego y definido sus características.
RA5-c	Se han creado las escenas del juego y distribuido los objetos en las mismas.
RA5-e	Se han establecido las propiedades físicas de los objetos.
RA5-g	Se han utilizado cámaras y configurado la iluminación.

1. Introducción: motores de juego y LibGDX#

1.1. ¿Por qué un motor de juego?#

Cuando desarrollamos una aplicación Android convencional con Jetpack Compose, delegamos en el sistema operativo la gestión del ciclo de renderizado: el sistema decide cuándo redibujar la interfaz en respuesta a cambios de estado. Este modelo, eficiente para formularios, listas o navegación, resulta inadecuado para videojuegos, donde la pantalla debe actualizarse de forma continua —típicamente entre 30 y 60 veces por segundo— independientemente de si ha cambiado algún dato.

Tema 9. Introducción a LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Tema 9. Introducción a LibGDX

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 3 horas

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

Criterios de Evaluación

Código	Criterio
RA4-a	Se han identificado los elementos que componen la arquitectura de un juego 2D y 3D.
RA4-b	Se han analizado los componentes de un motor de juegos.
RA4-c	Se han analizado entornos de desarrollo de juegos.
RA4-d	Se han analizado diferentes motores de juegos, sus características y funcionalidades.
RA4-e	Se han identificado los bloques funcionales de un juego existente.
RA4-f	Se ha reconocido la representación lógica y espacial de una escena gráfica sobre un juego existente.
RA5-a	Se ha establecido la lógica de un nuevo juego.
RA5-b	Se han creado los objetos necesarios para el juego y definido sus características.
RA5-c	Se han creado las escenas del juego y distribuido los objetos en las mismas.
RA5-e	Se han establecido las propiedades físicas de los objetos.
RA5-g	Se han utilizado cámaras y configurado la iluminación.

1. Introducción: motores de juego y LibGDX#

1.1. ¿Por qué un motor de juego?#

Cuando desarrollamos una aplicación Android convencional con Jetpack Compose, el sistema operativo decide cuándo redibujar la interfaz en respuesta a cambios de estado. Este modelo, eficiente para formularios y listas, resulta inadecuado para videojuegos, donde la pantalla debe actualizarse de forma continua —típicamente entre 30 y 60 veces por segundo— independientemente de si ha cambiado algún dato.

Tema 10. KotlinAsteroids — Juego de asteroides 2D completo

Mon, 01 Jan 0001 00:00:00 +0000

Tema 10: KotlinAsteroids — Juego de asteroides 2D completo

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 4 horas

Este tema desarrolla un proyecto guiado completo que integra todos los conceptos del Tema 9 aplicados a un juego top-down sin gravedad: Box2D con cuerpo libre, partículas, audio y múltiples pantallas. El juego sirve como referencia de arquitectura para el proyecto propio de evaluación.

Tema 10. KotlinPlatformer — Juego 2D completo

Mon, 01 Jan 0001 00:00:00 +0000

Tema 10. KotlinPlatformer — Juego 2D completo

Información del tema

Bloque: B5 — Motores de juego: análisis e introducción a LibGDX
Duración aproximada: 4 horas

Este tema desarrolla un proyecto guiado completo que integra todos los conceptos del Tema 9: Box2D, TiledMap, partículas, animaciones, audio y múltiples pantallas. El juego sirve como referencia de arquitectura para el proyecto propio de evaluación.

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

Criterios de Evaluación

Código	Criterio
RA4-e	Se han identificado los bloques funcionales de un juego existente.
RA4-f	Se ha reconocido la representación lógica y espacial de una escena gráfica sobre un juego existente.
RA5-a	Se ha establecido la lógica de un nuevo juego.
RA5-b	Se han creado los objetos necesarios para el juego y definido sus características.
RA5-c	Se han creado las escenas del juego y distribuido los objetos en las mismas.
RA5-d	Se han creado materiales para determinar las propiedades finales de la superficie de un objeto.
RA5-e	Se han establecido las propiedades físicas de los objetos.
RA5-f	Se ha incorporado sonido a los diferentes eventos del juego.
RA5-g	Se han utilizado cámaras y configurado la iluminación.
RA5-h	Se han desarrollado e implantado juegos para dispositivos móviles.
RA5-i	Se han realizado pruebas de funcionamiento y optimización de los juegos desarrollados.
RA5-j	Se han documentado las fases de diseño y desarrollo de los juegos creados.

1. Diseño del juego: KotlinPlatformer#

KotlinPlatformer es un juego de plataformas lateral 2D en el que el jugador controla un personaje que corre y salta sobre plataformas, recoge monedas y evita trampas. El objetivo es alcanzar el final del nivel con el mayor número de monedas posible.

Tema 1B. Introducción a Jetpack Compose

Mon, 01 Jan 0001 00:00:00 +0000

Tema 1B. Introducción a Jetpack Compose

Información del tema

Bloque: B1 — Fundamentos: Kotlin, Compose y entorno Android
Duración aproximada: 6 horas

Resultados de Aprendizaje

RA1 — Aplica tecnologías de desarrollo para dispositivos móviles evaluando sus características y capacidades.

Criterios de Evaluación

Código	Criterio
RA1-b	Se han identificado las tecnologías de desarrollo de aplicaciones para dispositivos móviles.
RA1-c	Se han instalado, configurado y utilizado entornos de trabajo para el desarrollo de aplicaciones para dispositivos móviles.
RA1-f	Se ha analizado la estructura de aplicaciones existentes para dispositivos móviles identificando las clases utilizadas.
RA1-g	Se han realizado modificaciones sobre aplicaciones existentes.
RA1-h	Se han utilizado emuladores para comprobar el funcionamiento de las aplicaciones.

1. ¿Qué es Jetpack Compose?#

Jetpack Compose es el framework moderno de Android para construir interfaces de usuario de forma declarativa. Fue publicado de forma estable por Google en 2021 y se ha convertido en la forma oficial y recomendada de desarrollar interfaces en Android, sustituyendo progresivamente al sistema clásico basado en archivos XML.

Tema 3. Navigation Compose

Mon, 01 Jan 0001 00:00:00 +0000

Información del tema

Bloque: B2 — Arquitectura MVVM y desarrollo de aplicaciones Android
Duración aproximada: 10 horas

Resultados de Aprendizaje

RA2 — Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.

Criterios de Evaluación

Código	Criterio
RA2-a	Se ha generado la estructura de clases necesaria para la aplicación.
RA2-c	Se han utilizado las clases necesarias para la conexión y comunicación con dispositivos inalámbricos.
RA2-g	Se han realizado pruebas de interacción usuario-aplicación para optimizar las aplicaciones desarrolladas a partir de emuladores.
RA2-i	Se han documentado los procesos necesarios para el desarrollo de las aplicaciones.

Dependencias necesarias#

 1// build.gradle.kts — plugins (nivel de proyecto o settings.gradle.kts)
 2plugins {
 3    id("org.jetbrains.kotlin.plugin.serialization") version "2.3.10" apply false
 4}
 5
 6// build.gradle.kts (app) — plugins del módulo
 7plugins {
 8    id("org.jetbrains.kotlin.plugin.serialization")
 9}
10
11// build.gradle.kts (app) — dependencias
12dependencies {
13    // Navigation Compose (API tipada disponible desde 2.8.0)
14    implementation("androidx.navigation:navigation-compose:2.9.7")
15
16    // Kotlin Serialization — imprescindible para las rutas @Serializable
17    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.10.0")
18}

Compatibilidad de versiones: El plugin kotlin.plugin.serialization debe tener exactamente la misma versión que Kotlin. Si tu proyecto usa Kotlin 2.1.20, el plugin debe ser también 2.1.20. Una discrepancia producirá errores de compilación difíciles de diagnosticar.

Tema 5. Retrofit2: Consumo de APIs REST

Mon, 01 Jan 0001 00:00:00 +0000

Tema 5. Retrofit2: Consumo de APIs REST

Información del tema

Bloque: B3 — Persistencia y comunicación: ROOM + Retrofit2
Duración aproximada: 12 horas

Resultados de Aprendizaje

RA2 — Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.
RA3 — Desarrolla programas que integran contenidos multimedia analizando y empleando las tecnologías y librerías específicas.

Criterios de Evaluación

Código	Criterio
RA2-a	Se ha generado la estructura de clases necesaria para la aplicación.
RA2-b	Se han analizado y utilizado las clases que modelan ventanas, menús, alertas y controles.
RA2-e	Se han utilizado las técnicas de acceso a servicios de comunicación en red disponibles.
RA2-g	Se han realizado pruebas de interacción usuario-aplicación para optimizar las aplicaciones desarrolladas.
RA2-i	Se han documentado los procesos necesarios para el desarrollo de las aplicaciones.
RA3-c	Se han utilizado clases para la conversión de datos multimedia de un formato a otro.
RA3-d	Se han utilizado clases para procesar datos multimedia.
RA3-e	Se han utilizado clases para el control de eventos, tipos de media y excepciones, entre otros.
RA3-h	Se han depurado y documentado los programas desarrollados.

Dependencias necesarias#

 1// build.gradle.kts (módulo app) — añadir a las dependencias de T4
 2dependencies {
 3    // Retrofit — cliente HTTP con soporte nativo a corrutinas
 4    implementation("com.squareup.retrofit2:retrofit:2.11.0")
 5    implementation("com.squareup.retrofit2:converter-gson:2.11.0")
 6
 7    // OkHttp — cliente HTTP subyacente + interceptor de logs para desarrollo
 8    implementation("com.squareup.okhttp3:okhttp:4.12.0")
 9    implementation("com.squareup.okhttp3:logging-interceptor:4.12.0")
10
11    // Gson — deserialización de JSON a objetos Kotlin/Java
12    implementation("com.google.code.gson:gson:2.11.0")
13
14    // Coil — carga asíncrona de imágenes en Compose
15    implementation("io.coil-kt.coil3:coil-compose:3.2.0")
16    implementation("io.coil-kt.coil3:coil-network-okhttp:3.2.0")
17}

Añadir el permiso de Internet en AndroidManifest.xml:

Tema 8. Sensores, GPS y Notificaciones

Mon, 01 Jan 0001 00:00:00 +0000

Tema 8. Sensores, GPS y Notificaciones#

Información del tema

Bloque: B4 — Multimedia en Android
Duración aproximada: 6 horas

Resultados de Aprendizaje

RA3 — Desarrolla programas que integran contenidos multimedia analizando y empleando las tecnologías y librerías específicas.

Criterios de Evaluación

Código	Criterio
RA3-a	Se han utilizado las herramientas y entornos de desarrollo para aplicaciones multimedia.
RA3-e	Se han gestionado los permisos de acceso al hardware multimedia del dispositivo.
RA3-f	Se han utilizado los servicios de localización del dispositivo.
RA3-g	Se han incorporado mecanismos de notificación y comunicación con el usuario.

Dependencias necesarias#

 1// build.gradle.kts (módulo app)
 2dependencies {
 3    // Localización con FusedLocationProviderClient
 4    // (Requiere Google Play Services — presente en la mayoría de dispositivos Android)
 5    implementation("com.google.android.gms:play-services-location:21.3.0")
 6
 7    // WorkManager — tareas en segundo plano y notificaciones programadas
 8    implementation("androidx.work:work-runtime-ktx:2.10.1")
 9
10    // Core KTX — NotificationCompat y utilidades de compatibilidad
11    // (Ya incluido transitivamente, pero conviene declararlo explícitamente)
12    implementation("androidx.core:core-ktx:1.16.0")
13}

Permisos en AndroidManifest.xml:

Anexo 3. Referencia: StateFlow, corrutinas y arquitectura MVVM

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 3. Referencia: StateFlow, corrutinas y arquitectura MVVM

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B2 — Arquitectura MVVM y desarrollo de aplicaciones Android

Resultados de Aprendizaje

RA2 — Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.

1. Corrutinas de Kotlin: referencia completa para ViewModel#

Qué es una corrutina#

Una corrutina es una unidad de trabajo que puede suspenderse y reanudarse sin bloquear el hilo en el que se ejecuta. Cuando una función suspend espera un resultado (una respuesta de red, una consulta a la base de datos), libera el hilo para que otras tareas lo usen, y lo recupera cuando el resultado está disponible.

Anexo 5. Referencia: Permisos en Android moderno, FileProvider y WorkManager avanzado

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 5. Referencia: Permisos en Android moderno, FileProvider y WorkManager avanzado#

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B4 — Multimedia en Android

Resultados de Aprendizaje

RA3 — Desarrolla programas que integran contenidos multimedia analizando y empleando las tecnologías y librerías específicas.

1. Mapa completo de permisos en Android#

Permisos peligrosos más habituales (solicitar en tiempo de ejecución)#

Grupo	Permiso	API	Cuándo es necesario
Cámara	`CAMERA`	Todos	Usar CameraX / Camera2
Almacenamiento	`READ_MEDIA_IMAGES`	33+	Leer imágenes sin Photo Picker
Almacenamiento	`READ_MEDIA_VIDEO`	33+	Leer vídeos sin Photo Picker
Almacenamiento	`READ_EXTERNAL_STORAGE`	≤32	Leer medios en API ≤ 32
Almacenamiento	`WRITE_EXTERNAL_STORAGE`	≤28	Escribir fuera de MediaStore
Micrófono	`RECORD_AUDIO`	Todos	Grabar audio / vídeo con sonido
Localización	`ACCESS_COARSE_LOCATION`	Todos	Red (~300m)
Localización	`ACCESS_FINE_LOCATION`	Todos	GPS (~10m)
Localización	`ACCESS_BACKGROUND_LOCATION`	29+	GPS con app en segundo plano
Notificaciones	`POST_NOTIFICATIONS`	33+	Publicar cualquier notificación
Actividad física	`ACTIVITY_RECOGNITION`	29+	Contador de pasos (`TYPE_STEP_COUNTER`)
Sensores corporales	`BODY_SENSORS`	Todos	Frecuencia cardíaca
Teléfono	`READ_PHONE_STATE`	Todos	Estado de la llamada
Contactos	`READ_CONTACTS`	Todos	Leer la agenda

Permisos normales (solo declarar en Manifest, no solicitar en runtime)#

1<uses-permission android:name="android.permission.INTERNET" />
2<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
3<uses-permission android:name="android.permission.VIBRATE" />
4<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

Flujo correcto para solicitar un permiso peligroso#

1. Comprobar si ya está concedido (ContextCompat.checkSelfPermission)
       │
       ├── GRANTED → Ejecutar la función directamente
       │
       └── DENIED
             │
             ├── shouldShowRequestPermissionRationale() == true
             │    → Mostrar explicación al usuario ANTES del diálogo
             │
             └── Lanzar launcher.launch(permiso)
                       │
                       ├── Usuario acepta → GRANTED → ejecutar función
                       │
                       └── Usuario deniega
                             │
                             ├── Primera denegación → puede volver a solicitar
                             └── "No volver a preguntar" → redirigir a Ajustes del sistema

Redirigir al usuario a los Ajustes si deniega permanentemente#

 1@Composable
 2fun MensajePermisoDenegadoPermanentemente(permiso: String) {
 3    val context = LocalContext.current
 4
 5    Column(
 6        horizontalAlignment = Alignment.CenterHorizontally,
 7        modifier = Modifier.padding(24.dp)
 8    ) {
 9        Icon(Icons.Default.Block, contentDescription = null,
10            modifier = Modifier.size(64.dp),
11            tint = MaterialTheme.colorScheme.error)
12        Spacer(Modifier.height(16.dp))
13        Text(
14            "El permiso ha sido denegado permanentemente. " +
15            "Ve a Ajustes → Aplicaciones → AppFlix → Permisos para activarlo.",
16            textAlign = TextAlign.Center
17        )
18        Spacer(Modifier.height(24.dp))
19        Button(onClick = {
20            // Abrir la pantalla de permisos de la app en los ajustes del sistema
21            val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
22                data = Uri.fromParts("package", context.packageName, null)
23            }
24            context.startActivity(intent)
25        }) {
26            Text("Ir a Ajustes")
27        }
28    }
29}

2. FileProvider: compartir archivos entre apps#

Cuando una app necesita compartir un archivo (foto tomada con CameraX, documento generado) con otra app (WhatsApp, email, Google Drive), no puede pasar una ruta de archivo directa (file:///) desde Android 7.0 (API 24). En su lugar, debe usar un FileProvider que genera una URI de contenido segura (content://).

Anexo 6. Referencia rápida de LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 6: Referencia rápida de LibGDX#

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B5 — Motores de juego: análisis e introducción a LibGDX

Este anexo actúa como hoja de consulta rápida durante el desarrollo del proyecto. Recoge las clases, métodos y patrones más usados del Tema 9 y el Tema 10 (KotlinAsteroids), organizados por área temática. Las secciones de física están adaptadas a juegos top-down sin gravedad.

Anexo 6. Referencia rápida de LibGDX

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 6: Referencia rápida de LibGDX#

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B5 — Motores de juego: análisis e introducción a LibGDX

Este anexo actúa como hoja de consulta rápida durante el desarrollo del proyecto. Recoge las clases, métodos y patrones más usados del Tema 9 y el Tema 10 (KotlinPlatformer), organizados por área temática.

Resultados de Aprendizaje

RA4 — Selecciona y prueba motores de juegos analizando la arquitectura de juegos 2D y 3D.
RA5 — Desarrolla juegos 2D y 3D sencillos utilizando motores de juegos.

1. Versiones y dependencias de referencia#

gradle.properties#

gdxVersion=1.13.1
ktxVersion=1.13.1-rc1
kotlinVersion=2.2.20

core/build.gradle.kts — dependencias completas#

 1dependencies {
 2    api("com.badlogicgames.gdx:gdx:$gdxVersion")
 3    api("com.badlogicgames.gdx:gdx-box2d:$gdxVersion")
 4    api("com.badlogicgames.gdx:gdx-freetype:$gdxVersion")   // fuentes TTF (opcional)
 5
 6    api("io.github.libktx:ktx-app:$ktxVersion")
 7    api("io.github.libktx:ktx-graphics:$ktxVersion")
 8    api("io.github.libktx:ktx-assets:$ktxVersion")
 9    api("io.github.libktx:ktx-math:$ktxVersion")
10    api("io.github.libktx:ktx-box2d:$ktxVersion")
11    api("io.github.libktx:ktx-tiled:$ktxVersion")
12}

android/build.gradle.kts — nativas Box2D y FreeType#

 1dependencies {
 2    implementation(project(":core"))
 3
 4    // Box2D nativas
 5    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-arm64-v8a")
 6    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-armeabi-v7a")
 7    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-x86")
 8    natives("com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-x86_64")
 9
10    // FreeType nativas (si se usa gdx-freetype)
11    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-arm64-v8a")
12    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-armeabi-v7a")
13    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-x86")
14    natives("com.badlogicgames.gdx:gdx-freetype-platform:$gdxVersion:natives-x86_64")
15}

2. Ciclo de vida — resumen visual#

AndroidLauncher.onCreate()
        │
        └─► initialize(MiJuego(), config)
                │
                ▼
        KtxGame.create()           ← inicializar batch, viewport, assets, primera pantalla
                │
                ├─► resize(w, h)   ← justo después de create() y en cada cambio de tamaño
                │
                │   ┌─────────────────────────────────────────┐
                │   │  BUCLE PRINCIPAL (~60 fps)              │
                │   │  render(delta)                          │
                │   │    ├── world.step(...)   [Box2D]        │
                │   │    ├── update entidades                 │
                │   │    └── draw()                           │
                │   └─────────────────────────────────────────┘
                │
                ├─► pause()        ← Home / llamada / bloqueo de pantalla
                ├─► resume()       ← volver a la app
                │
                └─► dispose()      ← cerrar app (puede no ejecutarse si el SO mata el proceso)
                       └── liberar: batch, assets, world, debugRenderer, particles, stage...

Métodos del ciclo de vida de KtxScreen#

Método	Se llama cuando	Acción típica
`show()`	La pantalla se activa	Configurar InputProcessor, iniciar música
`render(delta)`	Cada fotograma	update + draw
`resize(w, h)`	Cambio de tamaño	`viewport.update(w, h, true)`, `hud.resize(w, h)`
`pause()`	Pérdida de foco	Pausar música
`resume()`	Recuperar foco	Reanudar música
`hide()`	La pantalla se desactiva	(vacío en la mayoría de casos)
`dispose()`	Liberación explícita	`dispose()` en todos los recursos propios de esta pantalla

3. Renderizado — patrones de uso#

SpriteBatch con KTX#

 1// Patrón recomendado: use {} garantiza que end() siempre se llama
 2batch.use { b ->
 3    b.draw(textura, x, y, ancho, alto)
 4    b.draw(region, x, y, ancho, alto)   // TextureRegion
 5    fuente.draw(b, "Texto", x, y)
 6    particula.draw(b, delta)            // ParticleEffect
 7}
 8
 9// Sin KTX
10batch.begin()
11batch.draw(textura, x, y)
12batch.end()

ShapeRenderer#

 1// IMPORTANTE: batch debe estar cerrado (end()) antes de abrir ShapeRenderer
 2shapeRenderer.projectionMatrix = camera.combined
 3
 4// Líneas (contornos, debug)
 5shapeRenderer.begin(ShapeRenderer.ShapeType.Line)
 6shapeRenderer.color = Color.RED
 7shapeRenderer.rect(x, y, w, h)
 8shapeRenderer.circle(cx, cy, radio, 32)   // 32 = segmentos
 9shapeRenderer.line(x1, y1, x2, y2)
10shapeRenderer.end()
11
12// Relleno
13shapeRenderer.begin(ShapeRenderer.ShapeType.Filled)
14shapeRenderer.setColor(r, g, b, a)    // RGBA entre 0.0 y 1.0
15shapeRenderer.rect(x, y, w, h)
16shapeRenderer.end()

OrthogonalTiledMapRenderer#

1// Crear con el mismo unitScale que el viewport
2val renderer = OrthogonalTiledMapRenderer(tiledMap, unitScale, batch)
3
4// En render() — siempre DENTRO del mismo batch que el juego
5renderer.setView(camera)
6renderer.render()                      // todas las capas
7renderer.render(intArrayOf(0, 1))      // solo capas 0 y 1
8
9renderer.dispose()   // dispose() al cerrar la pantalla

4. Cámara y Viewport — referencia rápida#

 1// Crear viewport (elegir uno)
 2val viewport = FitViewport(WORLD_W, WORLD_H)       // barras negras, misma área siempre
 3val viewport = ExtendViewport(WORLD_W, WORLD_H)    // extiende el mundo, sin barras
 4val viewport = ScreenViewport()                    // 1:1 píxeles de pantalla
 5
 6// La cámara del viewport
 7val camera = viewport.camera as OrthographicCamera
 8camera.setToOrtho(false, WORLD_W, WORLD_H)  // false = Y crece hacia arriba
 9
10// En cada render()
11viewport.apply()           // aplica las bandas negras si procede
12camera.update()            // recalcula la matriz de proyección
13batch.projectionMatrix = camera.combined
14
15// En resize()
16viewport.update(width, height, true)  // true = centrar cámara
17
18// Seguir al jugador (con suavizado lerp)
19camera.position.x = MathUtils.lerp(camera.position.x, target.x, 5f * delta)
20camera.position.y = MathUtils.lerp(camera.position.y, target.y, 5f * delta)
21
22// Convertir toque de pantalla a coordenadas del mundo
23val touchVec = Vector3(Gdx.input.x.toFloat(), Gdx.input.y.toFloat(), 0f)
24viewport.unproject(touchVec)   // modifica touchVec in-place
25// Ahora: touchVec.x, touchVec.y = coordenadas del mundo

5. AssetManager — carga y acceso#

 1val assets = AssetManager()
 2
 3// Registrar loader de TiledMap (ANTES de encolar .tmx)
 4assets.setLoader(TiledMap::class.java, TmxMapLoader(InternalFileHandleResolver()))
 5
 6// Encolar assets para carga asíncrona
 7assets.load("atlas/juego.atlas",      TextureAtlas::class.java)
 8assets.load("mapas/nivel1.tmx",       TiledMap::class.java)
 9assets.load("audio/musica.ogg",       Music::class.java)
10assets.load("audio/salto.wav",        Sound::class.java)
11
12// Carga asíncrona (en LoadingScreen.render())
13if (assets.update()) { /* carga completa */ }
14val progreso: Float = assets.progress   // 0.0 a 1.0
15
16// Carga síncrona (bloquea)
17assets.finishLoading()
18
19// Acceso a assets ya cargados
20val atlas: TextureAtlas = assets.get("atlas/juego.atlas", TextureAtlas::class.java)
21val mapa:  TiledMap     = assets.get("mapas/nivel1.tmx",  TiledMap::class.java)
22
23// Liberación (libera TODOS los assets cargados)
24assets.dispose()

6. TextureAtlas y Animation#

 1// Cargar atlas
 2val atlas = TextureAtlas("atlas/juego.atlas")
 3
 4// Acceso por nombre
 5val region:  TextureRegion              = atlas.findRegion("moneda")
 6val regiones: Array<TextureAtlas.AtlasRegion> = atlas.findRegions("jugador_correr")
 7
 8// Crear animación
 9val frames = atlas.findRegions("jugador_correr")
10val animacion = Animation(
11    0.1f,              // duración de cada fotograma en segundos
12    *frames.toArray(), // spread operator para vararg
13    Animation.PlayMode.LOOP
14)
15
16// Obtener fotograma actual en render()
17tiempoAnim += delta
18val fotograma: TextureRegion = animacion.getKeyFrame(tiempoAnim)
19batch.draw(fotograma, x, y, w, h)
20
21// Voltear sprite horizontalmente (sin crear nueva región)
22batch.draw(region, x + w, y, -w, h)  // x desplazado + ancho negativo

7. Entrada del usuario#

 1// ── Polling (consultar cada frame) ────────────────────────────────────────
 2
 3Gdx.input.isTouched                    // true mientras el dedo esté presionado
 4Gdx.input.justTouched()                // true solo el PRIMER fotograma del toque
 5Gdx.input.x / Gdx.input.y             // posición del toque en píxeles de pantalla
 6
 7Gdx.input.isKeyPressed(Input.Keys.A)       // tecla mantenida
 8Gdx.input.isKeyJustPressed(Input.Keys.SPACE)  // tecla pulsada este fotograma
 9
10Gdx.input.accelerometerX              // inclinación izquierda-derecha (-10..10)
11Gdx.input.accelerometerY              // inclinación adelante-atrás
12
13// ── InputAdapter (eventos discretos) ─────────────────────────────────────
14
15Gdx.input.inputProcessor = object : InputAdapter() {
16    override fun touchDown(screenX: Int, screenY: Int, pointer: Int, button: Int): Boolean {
17        return true   // true = evento consumido
18    }
19    override fun keyDown(keycode: Int): Boolean {
20        if (keycode == Input.Keys.BACK) { /* botón atrás Android */ }
21        return false
22    }
23}
24
25// ── InputMultiplexer (varios receptores) ─────────────────────────────────
26
27val multiplexer = InputMultiplexer(stage, gameInput)  // stage tiene prioridad
28Gdx.input.inputProcessor = multiplexer

8. Audio#

 1// ── Sound: efectos cortos (< 5 s, cargados en memoria) ──────────────────
 2
 3val sfx: Sound = Gdx.audio.newSound(Gdx.files.internal("audio/salto.wav"))
 4// o via AssetManager:
 5val sfx: Sound = assets.get("audio/salto.wav", Sound::class.java)
 6
 7val id: Long = sfx.play(volume = 1.0f)             // devuelve ID de instancia
 8sfx.play(volume = 0.8f, pitch = 1.2f, pan = 0f)   // pitch: 0.5 (lento) a 2.0 (rápido)
 9sfx.stop(id)
10sfx.setLooping(id, true)
11sfx.dispose()
12
13// ── Music: pistas largas (streaming desde disco) ─────────────────────────
14
15val musica: Music = assets.get("audio/musica.ogg", Music::class.java)
16musica.isLooping = true
17musica.volume    = 0.6f      // 0.0 a 1.0
18musica.play()
19musica.pause()
20musica.stop()
21musica.isPlaying              // Boolean
22// NO llamar dispose() si es gestionada por AssetManager

9. Box2D — referencia completa#

Crear el World#

 1val world = World(Vector2(0f, -20f), true)  // gravedad, dormir inactivos
 2world.setContactListener(miListener)
 3
 4// Paso de simulación con tiempo fijo
 5private val TIME_STEP = 1f / 60f
 6private var accumulator = 0f
 7
 8fun step(delta: Float) {
 9    accumulator += delta.coerceAtMost(0.25f)
10    while (accumulator >= TIME_STEP) {
11        world.step(TIME_STEP, 8, 3)
12        accumulator -= TIME_STEP
13    }
14}
15
16world.dispose()  // siempre en dispose()

Crear cuerpos con KTX-Box2D#

 1// Cuerpo estático (plataforma)
 2val plataforma: Body = world.body {
 3    position.set(cx, cy)               // CENTRO del body
 4    // type = StaticBody por defecto en ktx-box2d
 5    box(halfWidth = w/2f, halfHeight = h/2f) {
 6        friction    = 0.6f
 7        restitution = 0f
 8        userData    = "suelo"          // identificador en ContactListener
 9    }
10}
11
12// Cuerpo dinámico (jugador)
13val jugador: Body = world.body(BodyDef.BodyType.DynamicBody) {
14    position.set(spawnX, spawnY)
15    fixedRotation = true               // evitar rotación al chocar con esquinas
16
17    // Fixture principal del cuerpo
18    box(halfWidth = 0.4f, halfHeight = 0.55f) {
19        density     = 1f
20        friction    = 0.1f
21        restitution = 0f
22        userData    = "jugador"
23    }
24
25    // Sensor de pies (detecta suelo sin respuesta física)
26    box(halfWidth = 0.35f, halfHeight = 0.1f,
27        position   = Vector2(0f, -0.65f)) {  // justo debajo del cuerpo
28        isSensor = true
29        userData = "pies_jugador"
30    }
31}
32
33// Sensor circular (moneda)
34val moneda: Body = world.body {
35    position.set(x, y)
36    circle(radius = 0.3f) {
37        isSensor = true
38        userData = "moneda"
39    }
40}

Aplicar movimiento al jugador (patrón plataformas)#

 1// Movimiento horizontal: impulso para respuesta inmediata
 2fun moverHorizontal(body: Body, direccion: Float, velocidadMax: Float) {
 3    val velActual  = body.linearVelocity.x
 4    val velDeseada = direccion * velocidadMax
 5    val impulso    = body.mass * (velDeseada - velActual)
 6    body.applyLinearImpulse(impulso, 0f,
 7        body.worldCenter.x, body.worldCenter.y, wake = true)
 8}
 9
10// Salto: impulso vertical instantáneo
11fun saltar(body: Body, fuerzaSalto: Float) {
12    val impulso = body.mass * fuerzaSalto
13    body.applyLinearImpulse(0f, impulso,
14        body.worldCenter.x, body.worldCenter.y, wake = true)
15}
16
17// Limitar velocidad vertical máxima (evitar velocidades infinitas en caída)
18val maxCaida = -20f
19if (body.linearVelocity.y < maxCaida) {
20    body.setLinearVelocity(body.linearVelocity.x, maxCaida)
21}

ContactListener#

 1world.setContactListener(object : ContactListener {
 2    override fun beginContact(contact: Contact) {
 3        val datA = contact.fixtureA.userData as? String
 4        val datB = contact.fixtureB.userData as? String
 5
 6        // ¿Pies del jugador tocan suelo?
 7        val piesEnSuelo = (datA == "pies_jugador" && datB == "suelo") ||
 8                          (datB == "pies_jugador" && datA == "suelo")
 9        if (piesEnSuelo) jugadorEnSuelo = true
10
11        // ¿Jugador recoge moneda?
12        if (datA == "jugador" && datB == "moneda")
13            accionesPendientes += { world.destroyBody(contact.fixtureB.body) }
14        if (datB == "jugador" && datA == "moneda")
15            accionesPendientes += { world.destroyBody(contact.fixtureA.body) }
16    }
17
18    override fun endContact(contact: Contact) {
19        val datA = contact.fixtureA.userData as? String
20        val datB = contact.fixtureB.userData as? String
21        if ((datA == "pies_jugador" && datB == "suelo") ||
22            (datB == "pies_jugador" && datA == "suelo")) {
23            jugadorEnSuelo = false
24        }
25    }
26
27    // OBLIGATORIOS aunque estén vacíos:
28    override fun preSolve(contact: Contact, oldManifold: Manifold) {}
29    override fun postSolve(contact: Contact, impulse: ContactImpulse) {}
30})
31
32// Ejecutar acciones diferidas DESPUÉS de world.step()
33accionesPendientes.forEach { it() }
34accionesPendientes.clear()

Box2DDebugRenderer#

1val debugRenderer = Box2DDebugRenderer()
2
3// En render(), después de dibujar el juego
4if (modoDebug) {
5    debugRenderer.render(world, camera.combined)
6}
7
8debugRenderer.dispose()   // en dispose()

10. TiledMap — referencia rápida#

Cargar mapa#

1// Con AssetManager (recomendado)
2assets.setLoader(TiledMap::class.java, TmxMapLoader(InternalFileHandleResolver()))
3assets.load("mapas/nivel1.tmx", TiledMap::class.java)
4// ...
5val map: TiledMap = assets.get("mapas/nivel1.tmx", TiledMap::class.java)
6
7// Sin AssetManager
8val map: TiledMap = TmxMapLoader().load("mapas/nivel1.tmx")

Renderizar mapa#

1// El unitScale debe ser 1f / tamañoTileEnPíxeles
2val renderer = OrthogonalTiledMapRenderer(map, 1f / 32f, batch)
3
4// En render()
5renderer.setView(camera)
6renderer.render()                      // todas las capas visibles
7renderer.render(intArrayOf(0, 1, 3))   // capas específicas por índice
8
9renderer.dispose()   // dispose() en la pantalla, NO en el mapa (el mapa lo gestiona AssetManager)

Extraer objetos y crear bodies Box2D#

 1val unitScale = 1f / 32f
 2
 3// Capa de rectángulos → bodies estáticos de suelo
 4val capaColisiones = map.layers.get("colisiones")
 5for (obj in capaColisiones.objects.getByType(RectangleMapObject::class.java)) {
 6    val r = obj.rectangle
 7    val x = r.x * unitScale;  val y = r.y * unitScale
 8    val w = r.width * unitScale;  val h = r.height * unitScale
 9    world.body {
10        position.set(x + w/2f, y + h/2f)
11        box(halfWidth = w/2f, halfHeight = h/2f) {
12            friction = 0.6f; userData = "suelo"
13        }
14    }
15}
16
17// Extraer posiciones de entidades por nombre
18val capaEntidades = map.layers.get("entidades")
19capaEntidades.objects.getByType(RectangleMapObject::class.java)
20    .filter { it.name == "moneda" }
21    .map    { Vector2(it.rectangle.x * unitScale, it.rectangle.y * unitScale) }
22    .forEach { pos -> crearMoneda(pos) }

Propiedades personalizadas (con ktx-tiled)#

1// En un objeto de la capa
2val velocidad: Float  = objeto.property("velocidad", defaultValue = 2f)
3val esDanino: Boolean = objeto.property("danino",    defaultValue = false)
4val tipo: String      = objeto.property("tipo",      defaultValue = "normal")

11. Partículas — referencia rápida#

 1// Cargar efecto (en create() o show(), no en render())
 2val efecto = ParticleEffect()
 3efecto.load(
 4    Gdx.files.internal("particles/polvo_salto.p"),
 5    Gdx.files.internal("particles")   // carpeta de la imagen de partícula
 6)
 7efecto.scaleEffect(1f / 32f)   // ajustar escala al mundo del juego
 8
 9// Posicionar y activar
10efecto.setPosition(x, y)
11efecto.start()
12
13// En render(), DENTRO de batch.use {}
14efecto.draw(batch, delta)   // actualiza Y dibuja en un solo paso
15
16// Estado
17efecto.isComplete    // true cuando todas las partículas han muerto
18efecto.isStarted     // true si está activo
19efecto.reset()       // reiniciar para reutilizar
20
21efecto.dispose()     // en dispose() de la pantalla

12. Fuentes — BitmapFont y FreeType#

 1// ── BitmapFont (fuente por defecto incluida en LibGDX) ───────────────────
 2
 3val fuente = BitmapFont()           // Arial 15px
 4fuente.color = Color.WHITE
 5fuente.data.setScale(1.5f)         // escala (permanente; resetear después si es necesario)
 6
 7// Dentro de batch.use {}
 8fuente.draw(batch, "Texto", x, y)
 9
10// GlyphLayout: para medir dimensiones antes de dibujar (centrar texto)
11val layout = GlyphLayout(fuente, "¡GAME OVER!")
12val textX  = (WORLD_W - layout.width) / 2f
13fuente.draw(batch, layout, textX, y)
14
15fuente.dispose()   // en dispose()
16
17// ── FreeType (fuentes TTF personalizadas) ────────────────────────────────
18
19val generator = FreeTypeFontGenerator(Gdx.files.internal("fuentes/roboto.ttf"))
20val params = FreeTypeFontGenerator.FreeTypeFontParameter().apply {
21    size        = 32
22    color       = Color.WHITE
23    borderWidth = 1f
24    borderColor = Color.BLACK
25    characters  = FreeTypeFontGenerator.DEFAULT_CHARS + "áéíóúÁÉÍÓÚñÑ¡¿"
26}
27val fuenteTTF: BitmapFont = generator.generateFont(params)
28generator.dispose()     // liberar el generador (la fuente resultante sigue siendo válida)
29// fuenteTTF.dispose() en dispose() de la pantalla

13. Scene2D — Stage y Table para HUD#

 1// Stage con viewport propio (independiente de la cámara del juego)
 2val stage = Stage(ScreenViewport(), batch)
 3
 4// Conectar al InputMultiplexer si se necesita entrada en el HUD
 5Gdx.input.inputProcessor = InputMultiplexer(stage, gameInput)
 6
 7// Table: layout declarativo
 8val tabla = Table()
 9tabla.top().setFillParent(true)     // anclar al borde superior, tamaño de pantalla
10
11val estilo = Label.LabelStyle(fuente, Color.WHITE)
12val labelMonedas = Label("Monedas: 0", estilo)
13val labelVidas   = Label("Vidas: 3",   estilo)
14
15tabla.add(labelMonedas).expandX().left().pad(10f)
16tabla.add(labelVidas).expandX().right().pad(10f)
17
18stage.addActor(tabla)
19
20// Actualizar texto de las etiquetas
21labelMonedas.setText("Monedas: ${game.monedasRecogidas}")
22
23// En render() — DESPUÉS de dibujar el juego
24stage.act(delta)
25stage.draw()
26
27// En resize()
28stage.viewport.update(width, height, true)
29
30stage.dispose()   // en dispose()

14. Launcher Android — AndroidManifest.xml#

 1<!-- AndroidManifest.xml -->
 2<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 3
 4    <application
 5        android:icon="@drawable/ic_launcher"
 6        android:label="@string/app_name">
 7
 8        <activity
 9            android:name=".android.AndroidLauncher"
10            android:label="@string/app_name"
11            android:screenOrientation="landscape"
12            android:configChanges="keyboard|keyboardHidden|navigation|orientation|screenSize|screenLayout"
13            android:exported="true">
14            <intent-filter>
15                <action android:name="android.intent.action.MAIN" />
16                <category android:name="android.intent.category.LAUNCHER" />
17            </intent-filter>
18        </activity>
19
20    </application>
21</manifest>

 1// AndroidLauncher.kt
 2class AndroidLauncher : AndroidApplication() {
 3    override fun onCreate(savedInstanceState: Bundle?) {
 4        super.onCreate(savedInstanceState)
 5        val config = AndroidApplicationConfiguration().apply {
 6            useAccelerometer = false
 7            useCompass       = false
 8            useGyroscope     = false
 9            useWakelock      = true          // evitar apagado de pantalla
10            useImmersiveMode = true          // pantalla completa
11        }
12        initialize(KotlinPlatformGame(), config)
13    }
14}

15. Tabla de errores comunes y soluciones#

Error	Causa	Solución
`OpenGLException` al arrancar	`Texture` / `SpriteBatch` creados antes de `create()`	Moverlos al cuerpo de `create()` o usar `lateinit`
`IllegalStateException: called begin()`	`begin()` sin `end()` anterior, o SpriteBatch + ShapeRenderer activos a la vez	Asegurarse de que cada `begin()` tiene su `end()` antes del siguiente
Jugador rota al golpear esquinas	`fixedRotation = false` (valor por defecto)	Poner `fixedRotation = true` en el BodyDef del jugador
Sensor de pies nunca detecta suelo	La fixture sensor tiene el mismo `userData` que la principal	Asignar `userData = "pies_jugador"` solo al sensor, `"jugador"` al cuerpo
Crash `Box2D: assertion` al destruir body	`destroyBody()` llamado dentro de `ContactListener`	Encolar la destrucción en una lista; ejecutar después de `world.step()`
Mapa y bodies Box2D con escala diferente	`unitScale` distinto en `MapLoader` y `OrthogonalTiledMapRenderer`	Usar la misma constante `UNIT_SCALE = 1f / 32f` en ambos
Mapa no se ve / pantalla negra	`mapRenderer.setView(camera)` no llamado antes de `render()`	Llamar a `setView()` en cada fotograma
El atlas no carga	El archivo `.atlas` o `.png` no está en `android/assets/`	Verificar ruta y copiar ambos archivos al directorio correcto
Fugas de memoria en GPU	Assets no liberados con `dispose()`	Revisar que todos los `Texture`, `SpriteBatch`, `ShapeRenderer`, `Sound`, `TiledMap` y `ParticleEffect` tienen su `dispose()`
Movimiento dependiente de framerate	Velocidades fijas sin multiplicar por `delta`	Siempre: `posicion += velocidad * delta`
Coordenadas de toque incorrectas	Usar `Gdx.input.x/y` directamente sin `unproject`	`viewport.unproject(Vector3(x.toFloat(), y.toFloat(), 0f))`
Partículas demasiado grandes	`ParticleEffect` creado en píxeles; mundo en unidades	`efecto.scaleEffect(1f / 32f)` después de cargar
Música no se pausa al minimizar	`pause()` de Screen no gestiona la música	Sobreescribir `pause()` y llamar a `musica.pause()`

16. Checklist de entrega del proyecto#

Antes de presentar el proyecto, verificar que:

Tema 1C. Interfaz de usuario avanzada en Compose

Mon, 01 Jan 0001 00:00:00 +0000

Tema 1C. Interfaz de usuario avanzada en Compose

Información del tema

Bloque: B1 — Fundamentos: Kotlin, Compose y entorno Android
Duración aproximada: 4 horas

Resultados de Aprendizaje

RA1 — Aplica tecnologías de desarrollo para dispositivos móviles evaluando sus características y capacidades.

Criterios de Evaluación

Código	Criterio
RA1-b	Se han identificado las tecnologías de desarrollo de aplicaciones para dispositivos móviles.
RA1-d	Se han identificado configuraciones que clasifican los dispositivos móviles en base a sus características.
RA1-g	Se han realizado modificaciones sobre aplicaciones existentes.
RA1-h	Se han utilizado emuladores para comprobar el funcionamiento de las aplicaciones.

1. Ecosistema Android y limitaciones del dispositivo móvil#

Antes de profundizar en la UI, es importante entender el entorno en el que se ejecutan las aplicaciones Android y las restricciones que impone.

Tema 6. Integración Room + Retrofit2: Arquitectura offline-first

Mon, 01 Jan 0001 00:00:00 +0000

Tema 6. Integración Room + Retrofit2: Arquitectura offline-first

Información del tema

Bloque: B3 — Persistencia y comunicación: ROOM + Retrofit2
Duración aproximada: 10 horas

Resultados de Aprendizaje

RA2 — Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.
RA3 — Desarrolla programas que integran contenidos multimedia analizando y empleando las tecnologías y librerías específicas.

Criterios de Evaluación

Código	Criterio
RA2-a	Se ha generado la estructura de clases necesaria para la aplicación.
RA2-e	Se han utilizado las técnicas de acceso a servicios de comunicación en red disponibles.
RA2-f	Se han almacenado y recuperado datos utilizando algún mecanismo de persistencia.
RA2-g	Se han realizado pruebas de interacción usuario-aplicación para optimizar las aplicaciones desarrolladas.
RA2-i	Se han documentado los procesos necesarios para el desarrollo de las aplicaciones.
RA3-c	Se han utilizado clases para la conversión de datos multimedia de un formato a otro.
RA3-d	Se han utilizado clases para procesar datos multimedia.
RA3-e	Se han utilizado clases para el control de eventos, tipos de media y excepciones, entre otros.
RA3-h	Se han depurado y documentado los programas desarrollados.

1. El problema de combinar dos fuentes de datos#

En T4 la app guardaba películas en Room. En T5 se consumió la API de TMDB. Ahora hay que resolver la pregunta más importante de la capa de datos: ¿cuándo mostramos datos locales y cuándo datos de la red? ¿Qué pasa si no hay conexión?

Anexo 4. Referencia: Room avanzado, migraciones, testing y API Key segura

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 4. Referencia: Room avanzado, migraciones, testing y API Key segura

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B3 — Persistencia y comunicación: ROOM + Retrofit2

Resultados de Aprendizaje

RA2 — Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.
RA3 — Desarrolla programas que integran contenidos multimedia analizando y empleando las tecnologías y librerías específicas.

1. Almacenar la API Key de forma segura#

La API Key de TMDB nunca debe aparecer directamente en el código fuente ni subirse a un repositorio de control de versiones. El método estándar en Android es almacenarla en local.properties y acceder a ella a través de BuildConfig.

Tema 1D. Intents, permisos y entorno Android

Mon, 01 Jan 0001 00:00:00 +0000

Tema 1D. Intents, permisos y entorno Android

Información del tema

Bloque: B1 — Fundamentos: Kotlin, Compose y entorno Android
Duración aproximada: 4 horas

Resultados de Aprendizaje

RA1 — Aplica tecnologías de desarrollo para dispositivos móviles evaluando sus características y capacidades.

Criterios de Evaluación

Código	Criterio
RA1-a	Se han analizado las limitaciones que plantea la ejecución de aplicaciones en los dispositivos móviles.
RA1-c	Se han instalado, configurado y utilizado entornos de trabajo para el desarrollo de aplicaciones para dispositivos móviles.
RA1-d	Se han identificado configuraciones que clasifican los dispositivos móviles en base a sus características.
RA1-e	Se han descrito perfiles que establecen la relación entre el dispositivo y la aplicación.
RA1-f	Se ha analizado la estructura de aplicaciones existentes para dispositivos móviles identificando las clases utilizadas.
RA1-g	Se han realizado modificaciones sobre aplicaciones existentes.
RA1-h	Se han utilizado emuladores para comprobar el funcionamiento de las aplicaciones.

1. El ciclo de vida de una Activity#

Antes de estudiar los Intents, es esencial comprender el ciclo de vida de una Activity, porque determina cuándo se crean, pausan, reanudan y destruyen las pantallas de una app.

Anexo 1. Kotlin — Referencia Completa

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 1. Kotlin para Android

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B1 — Fundamentos: Kotlin, Compose y entorno Android

Resultados de Aprendizaje

RA1 — Aplica tecnologías de desarrollo para dispositivos móviles evaluando sus características y capacidades.

Sobre este anexo#

Este documento es una referencia completa del lenguaje Kotlin orientada al desarrollo Android. Su objetivo es doble: servir como material de consulta durante el curso cuando necesites recordar la sintaxis o el comportamiento de un elemento del lenguaje, y como recurso de profundización para quien quiera ir más allá del repaso acelerado.

Anexo 2. Remember en Jetpack Compose

Mon, 01 Jan 0001 00:00:00 +0000

Anexo 2: Funciones `remember` en Jetpack Compose

Información del anexo

Tipo: Anexo de apoyo — material de consulta y profundización
Bloque: B1 — Fundamentos: Kotlin, Compose y entorno Android

Resultados de Aprendizaje

RA1 — Aplica tecnologías de desarrollo para dispositivos móviles evaluando sus características y capacidades.

1. Básicos de estado#

Función	Descripción	Ejemplo rápido
`remember {…}`	Guarda el estado en recomposición mientras el composable esté en el árbol.	`val count = remember { mutableStateOf(0) }`
`rememberSaveable {…}`	Igual que `remember`, pero persiste en recreaciones de actividad (rotación, proceso).	`val count = rememberSaveable { mutableStateOf(0) }`

2. Corutinas y lambdas#

Función	Descripción	Ejemplo rápido
`rememberCoroutineScope()`	Devuelve un `CoroutineScope` ligado al ciclo de vida del composable.	`val scope = rememberCoroutineScope()`
`rememberUpdatedState(value)`	Mantiene siempre la última versión de un valor dentro de efectos (`LaunchedEffect`, etc.).	`val onClick by rememberUpdatedState(newValue = action)`

3. Animaciones#

Función	Descripción	Ejemplo rápido
`rememberInfiniteTransition()`	Animaciones que se repiten indefinidamente.	`val alpha by infinite.animateFloat(... )`
`rememberTransition(state)`	Transiciones entre estados definidos.	`val transition = updateTransition(targetState, label="")`
`rememberSplineBasedDecay()`	Animación tipo fling con decaimiento.	`val decay = rememberSplineBasedDecay<Float>()`

4. Scroll y listas#

Función	Descripción	Ejemplo rápido
`rememberScrollState()`	Guarda la posición de scroll en `Column` / `Row`.	`val scroll = rememberScrollState()`
`rememberLazyListState()`	Guarda el estado de scroll en `LazyColumn`/`LazyRow`.	`val listState = rememberLazyListState()`
`rememberLazyGridState()`	Estado de scroll en `LazyVerticalGrid` o `LazyHorizontalGrid`.	`val gridState = rememberLazyGridState()`
`rememberPagerState()`	Estado de un pager (`HorizontalPager` / `VerticalPager`).	`val pagerState = rememberPagerState()`

5. Gestos e interacción#

Función	Descripción	Ejemplo rápido
`rememberDraggableState(onDelta)`	Controla los desplazamientos en gestos de arrastre.	`val dragState = rememberDraggableState { delta -> … }`
`rememberSwipeableState(initialValue)`	Estado de un componente deslizable (ej: `BottomSheet`).	`val sheetState = rememberSwipeableState(0)`
`rememberPullRefreshState(refreshing, onRefresh)`	Estado para pull-to-refresh.	`val refreshState = rememberPullRefreshState(refreshing, { … })`
`rememberNestedScrollInteropConnection()`	Conexión de scroll con vistas clásicas Android.	`val connection = rememberNestedScrollInteropConnection()`

6. Otros especializados#

Función	Descripción	Ejemplo rápido
`rememberSystemUiController()` (Accompanist)	Controla status bar y nav bar.	`val controller = rememberSystemUiController()`
`rememberInsetsPaddingValues()` (Accompanist, deprecated)	Padding según insets del sistema.	`val padding = rememberInsetsPaddingValues()`
`rememberHapticFeedback()`	Acceso al motor de vibración/háptica.	`val haptic = LocalHapticFeedback.current`
`rememberClipboardManager()`	Acceso al portapapeles del sistema.	`val clipboard = LocalClipboardManager.current`

Ejemplo práctico integrando varios `remember`#

 1@Composable
 2fun DemoRememberScreen() {
 3    val count = rememberSaveable { mutableStateOf(0) }
 4    val scrollState = rememberScrollState()
 5    val scope = rememberCoroutineScope()
 6    val transition = rememberInfiniteTransition()
 7
 8    val alpha by transition.animateFloat(
 9        initialValue = 0f,
10        targetValue = 1f,
11        animationSpec = infiniteRepeatable(
12            animation = tween(1000),
13            repeatMode = RepeatMode.Reverse
14        )
15    )
16
17    Column(
18        modifier = Modifier
19            .fillMaxSize()
20            .verticalScroll(scrollState),
21        horizontalAlignment = Alignment.CenterHorizontally
22    ) {
23        Text("Contador: ${count.value}", modifier = Modifier.alpha(alpha))
24
25        Button(onClick = {
26            scope.launch { count.value++ }
27        }) {
28            Text("Incrementar")
29        }
30    }
31}

Referencias y recursos#

Showcases

Mon, 01 Jan 0001 00:00:00 +0000

At the moment this page is empty#