Preparación para entrevistas Mobile Developer

Preguntas de entrevista para Mobile Developer

20 preguntas frecuentes de entrevista para Mobile Developer. El desarrollo móvil es un área muy demandada centrada en crear apps fiables para iOS, Android y multiplataforma, resolviendo tareas de producto, rendimiento, releases, modo offline e integración con dispositivos. Las preguntas cubren distintos niveles, y puedes practicar respondiéndolas en voz alta en nuestro simulador de entrevistas.

Empezar una entrevista IA para Mobile DeveloperNo se requiere tarjeta de crédito. 1 sesión gratuita disponible.
Práctica de entrevistas técnicas en inglésDiseñado para hablantes no nativos que desean practicar entrevistas técnicas en inglés.

Preguntas para principiantes

1¿Cuál es la diferencia entre almacenar un token de autenticación en un almacenamiento clave-valor estándar como SharedPreferences o UserDefaults y hacerlo en un almacenamiento seguro de la plataforma como Android Keystore o iOS Keychain?

SharedPreferences y UserDefaults son almacenes de preferencias, no almacenes dedicados para secretos. Sus archivos están protegidos por el aislamiento de aplicaciones (app sandboxing) y la protección de almacenamiento del SO (sistema operativo) aplicable, pero las API (interfaces de programación de aplicaciones) de preferencias no añaden cifrado específico para secretos ni políticas de acceso. iOS Keychain almacena secretos como tokens con políticas configurables de accesibilidad, sincronización y control de acceso. Android Keystore almacena y opera con claves criptográficas en lugar de cadenas de tokens arbitrarias; una aplicación puede cifrar un token con una clave gestionada por Keystore y almacenar el texto cifrado por separado. Las claves de Keystore pueden estar respaldadas por software o por hardware según el dispositivo, el algoritmo y la configuración; verifique el nivel de seguridad en lugar de asumir TEE (entorno de ejecución de confianza)/StrongBox. Las claves respaldadas por hardware pueden permanecer como no exportables, pero los tokens descifrados aún entran en la memoria de la aplicación, y una aplicación o dispositivo comprometido puede hacer un uso indebido de las operaciones autorizadas. Elija deliberadamente las políticas de copia de seguridad y autenticación.

// --- ANDROID ---
// INSECURE (Plain SharedPreferences):
val prefs = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
prefs.edit().putString("auth_token", token).apply() // Plaintext XML on disk

// SECURE (EncryptedSharedPreferences backed by Android Keystore):
val masterKey = MasterKey.Builder(context)
    .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
    .build()
val securePrefs = EncryptedSharedPreferences.create(
    context,
    "secure_prefs",
    masterKey,
    EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
    EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
securePrefs.edit().putString("auth_token", token).apply()

// --- IOS (Swift) ---
// INSECURE:
UserDefaults.standard.set(token, forKey: "auth_token") // Plain plist on disk

// SECURE (Keychain Services API):
let query: [String: Any] = [
    kSecClass as String: kSecClassGenericPassword,
    kSecAttrAccount as String: "user_auth_token",
    kSecValueData as String: token.data(using: .utf8)!,
    kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlocked
]
SecItemAdd(query as CFDictionary, nil)
Probar responder esta pregunta con un coach de IA

2¿Cuál es el propósito principal de un pipeline de CI/CD (integración continua y entrega continua) móvil y qué etapas y restricciones únicas lo diferencian de los pipelines de despliegue web o backend?

El propósito principal de un pipeline de CI/CD móvil es automatizar la compilación, las pruebas, la firma y la distribución de aplicaciones cliente móviles para mantener una calidad consistente y lanzamientos repetibles. La integración continua (CI) valida los cambios de código mediante compilaciones automatizadas, análisis estático y pruebas unitarias. La entrega/despliegue continuo (CD) empaqueta, firma y distribuye artefactos binarios a canales de prueba (como TestFlight o Firebase App Distribution) o a tiendas de aplicaciones. El CI/CD móvil se diferencia de los pipelines web y backend en varios aspectos clave: 1. **Tipo de artefacto:** Las compilaciones generan binarios cliente compilados (`.ipa`, `.apk`, `.aab`) en lugar de ejecutarse directamente en servidores o dentro de imágenes de contenedores. 2. **Restricciones de hardware del ejecutor (runner):** La compilación para iOS requiere hardware con macOS y las herramientas de línea de comandos de Xcode, mientras que los pipelines de backend suelen ejecutarse en contenedores Linux ligeros. 3. **Latencia de lanzamiento y aprobaciones:** La publicación para los usuarios finales implica ciclos de revisión de tiendas de aplicaciones de terceros (Apple App Store / Google Play Store), lo que significa que los despliegues no se pueden revertir instantáneamente mediante un redespliegue en el servidor. Las correcciones requieren el envío de un nuevo binario firmado o el uso de feature flags en tiempo de ejecución.

name: Mobile CI/CD Workflow

on:
  pull_request:
    branches: [main]
  push:
    tags:
      - 'v*.*.*'

jobs:
  ci_validation:
    name: Lint & Unit Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Linter
        run: ./gradlew lint
      - name: Run Unit Tests
        run: ./gradlew testDebugUnitTest

  cd_release_ios:
    name: Build & Distribute iOS
    needs: ci_validation
    if: startsWith(github.ref, 'refs/tags/v')
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - name: Install Signing Certificates
        run: fastlane match appstore --readonly
      - name: Build & Upload to TestFlight
        run: fastlane ios beta
Probar responder esta pregunta con un coach de IA

3En una aplicación móvil multiplataforma, ¿cuál es el propósito de separar las capas de presentación, dominio y datos, y cómo facilita esta estructura el código compartido entre iOS y Android?

Separar una aplicación en capas de presentación, dominio y datos establece límites claros de responsabilidad: 1. **Capa de presentación:** Gestiona el renderizado de la interfaz de usuario (UI), la entrada del usuario y el estado a nivel de pantalla (por ejemplo, Views, Widgets, ViewModels o Presenters). 2. **Capa de dominio:** Encapsula la lógica de negocio pura, los modelos o entidades de dominio y los casos de uso. Permanece independiente de la UI y de los frameworks de la plataforma. 3. **Capa de datos:** Administra la recuperación y persistencia de datos desde APIs remotas, bases de datos locales o la caché del dispositivo mediante repositorios y fuentes de datos. En el desarrollo móvil multiplataforma, esta estructura facilita compartir código porque las capas de dominio y datos son agnósticas respecto a la plataforma. Las reglas de negocio centrales, las transformaciones de datos y el manejo de red se pueden compartir al 100% entre iOS y Android, lo que permite a los equipos compartir toda la pila (como en Flutter o React Native) o compartir la lógica de negocio y datos mientras mantienen capas de presentación nativas específicas de cada plataforma (como en Kotlin Multiplatform).

[Presentation Layer] (UI, Screens, ViewModels)
         │
         ▼ calls
[Domain Layer]       (Use Cases, Business Rules, Entities)
         ▲
         │ implements interfaces
[Data Layer]         (Repositories, API Clients, Local Storage)
Probar responder esta pregunta con un coach de IA

4¿Cuáles son las diferencias principales entre los paradigmas de desarrollo de interfaces de usuario (UI) imperativo y declarativo en la ingeniería móvil, y cómo plasman el modelo declarativo los widgets de Flutter y los componentes de React Native?

En el desarrollo de UI imperativo, los desarrolladores escriben instrucciones explícitas paso a paso para crear, mutar y destruir elementos de la interfaz (como buscar una vista por ID y llamar directamente a métodos como setText o setVisibility). Por el contrario, los modelos declarativos de UI describen cómo debería verse la interfaz para un estado determinado (a menudo expresado como UI = f(state)). Cuando el estado cambia, el framework determina cómo actualizar la representación visual de manera eficiente. Tanto Flutter como React Native representan este paradigma declarativo. En Flutter, los widgets son descripciones de configuración inmutables; cuando los datos dinámicos cambian, llamar a setState() en un StatefulWidget programa una reconstrucción donde el método build() devuelve una nueva descripción del árbol de widgets que Flutter reconcilia con sus árboles de Element y RenderObject. En React Native, los componentes son funciones o clases que devuelven JSX; actualizar el estado o las props desencadena un nuevo renderizado donde React reconcilia el árbol de elementos virtuales y aplica las actualizaciones nativas mínimas necesarias a través del bridge o del entorno de ejecución nativo.

class CounterWidget extends StatefulWidget {
  const CounterWidget({super.key});
  @override
  State<CounterWidget> createState() => _CounterWidgetState();
}

class _CounterWidgetState extends State<CounterWidget> {
  int _count = 0;

  void _increment() {
    setState(() {
      _count++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: _increment,
      child: Text('Count: $_count'),
    );
  }
}
Probar responder esta pregunta con un coach de IA

5¿Cuál es la diferencia operativa entre un arranque en frío (cold start), un arranque templado (warm start) y un arranque en caliente (hot start) en aplicaciones móviles, y por qué el cold start es la métrica más crítica para los presupuestos de rendimiento?

En el ciclo de vida de las aplicaciones móviles, los estados de inicio varían según si el proceso de la aplicación y su estado en memoria ya existen en el sistema operativo: - Arranque en frío (cold start): La aplicación se inicia desde cero porque el sistema operativo no ha creado su proceso o este fue terminado previamente. El sistema debe asignar un nuevo proceso, cargar binarios/entornos de ejecución, inicializar el contexto de la aplicación/runtime e inflar la primera vista. Es el que presenta la mayor latencia. - Arranque templado (warm start): El proceso de la aplicación suele estar ya en memoria, pero la jerarquía de vistas o la actividad fue destruida o desalojada (por ejemplo, debido a una recreación en segundo plano o navegación hacia atrás). El sistema operativo vuelve a crear la UI/actividad sin necesidad de generar un nuevo proceso desde cero. - Arranque en caliente (hot start): La aplicación y el estado de su UI siguen completamente residentes en memoria (por ejemplo, el usuario pulsó Inicio y regresó de inmediato). El sistema operativo simplemente trae la jerarquía de vistas existente al primer plano prácticamente sin sobrecarga de inicialización. El cold start es la métrica más crítica para los presupuestos de rendimiento porque representa la primera impresión y la experiencia más lenta para los usuarios. Tiempos prolongados de cold start se correlacionan directamente con el abandono inmediato de la aplicación, una menor retención y un peor posicionamiento en las tiendas de aplicaciones (como los umbrales de Android Vitals).

Cold Start: [OS Process Spawn] -> [App Runtime Init] -> [Activity/UI Creation] -> [First Frame Drawn]
Warm Start: [Existing Process]  -> [Activity/UI Recreation] -> [First Frame Drawn]
Hot Start:  [Existing Process]  -> [Bring Existing View to Foreground] (Instant)
Probar responder esta pregunta con un coach de IA

6¿Qué es un puente nativo (native bridge) en una aplicación móvil multiplataforma y cuándo utilizarías uno en lugar de escribir la funcionalidad por completo en código de Flutter o React Native?

Un puente nativo (native bridge) es la capa de comunicación que permite al código multiplataforma llamar a código específico de iOS o Android, y permite al código nativo devolver resultados o enviar eventos. En Flutter esto se realiza comúnmente mediante canales de plataforma o complementos. En React Native se hace habitualmente con módulos nativos, TurboModules o componentes de interfaz de usuario nativos. Se utiliza un puente cuando una funcionalidad requiere algo a lo que el código puro de Flutter o React Native no puede acceder adecuadamente, como una API de la plataforma, una capacidad del dispositivo, un kit de desarrollo de software (SDK) nativo, una implementación nativa crítica para el rendimiento o un componente de interfaz de usuario nativo. Algunos ejemplos comunes incluyen funciones de cámara, Bluetooth, notificaciones push, pagos, almacenamiento seguro, servicios en segundo plano, API de salud o SDK que solo ofrecen integraciones en Swift/Objective-C o Kotlin/Java. Un buen puente suele exponer una API pequeña y clara a la capa multiplataforma, como `getBatteryLevel`, `startBluetoothScan` o `openNativePaymentSheet`, mientras que la implementación específica de la plataforma gestiona los detalles reales de iOS y Android.

Cross-platform screen:
  calls NativePayments.openPaymentSheet(orderId)

iOS implementation:
  uses Apple Pay / native payment SDK

Android implementation:
  uses Google Pay / native payment SDK
Probar responder esta pregunta con un coach de IA

7¿Qué significa una arquitectura que prioriza el funcionamiento sin conexión (offline-first) en el desarrollo móvil y en qué se diferencia fundamentalmente del almacenamiento en caché de respuestas HTTP (protocolo de transferencia de hipertexto) estándar?

En el desarrollo móvil, una arquitectura offline-first considera el almacenamiento local como la fuente primaria de verdad tanto para operaciones de lectura como de escritura. En lugar de esperar a que se completen las solicitudes de red antes de renderizar o permitir la interacción del usuario, la aplicación interactúa directamente con la base de datos o capa de almacenamiento local, mientras que procesos de sincronización en segundo plano se encargan de conciliar los cambios locales con el servidor remoto cuando hay conectividad disponible. Esto difiere fundamentalmente del almacenamiento en caché de respuestas HTTP estándar en varios aspectos: 1. **Modelo de datos**: El almacenamiento en caché HTTP guarda respuestas de red en bruto (por ejemplo, cargas útiles en JSON) indexadas por URL y encabezados de solicitud. La arquitectura offline-first almacena entidades de dominio estructuradas en una base de datos local (como Room, SQLite o SwiftData/Core Data). 2. **Escrituras frente a lecturas**: El almacenamiento en caché HTTP es primordialmente un mecanismo de optimización de lectura y no admite de forma nativa transacciones o mutaciones de escritura sin conexión. Offline-first permite escrituras locales completas, encolando las mutaciones para sincronizarlas posteriormente con el servidor. 3. **Capacidad de consulta y ciclo de vida**: Las respuestas HTTP almacenadas en caché están sujetas a políticas de desalojo automático de caché y no se pueden consultar, filtrar ni combinar arbitrariamente. La persistencia offline-first ofrece capacidades completas de consulta, indexación y una gestión determinista del ciclo de vida independiente del estado de la red.

/* Network-First with HTTP Caching */
UI -> Network Request -> [Cache Hit ? Return Cached JSON : Fetch from API -> Save to HTTP Cache] -> UI
// Limitation: Read-only optimization; offline writes fail immediately.

/* Offline-First with Local Source of Truth */
UI <-> Observes Local DB (e.g., Room / Core Data / SQLite)
User Write -> Write to Local DB -> Queue Sync Task
Sync Worker (Background) -> Send queued mutations to Server -> Update Local DB with Server Response
Probar responder esta pregunta con un coach de IA

8¿Cuál es la diferencia entre una notificación push remota y una notificación local en una aplicación móvil?

La principal diferencia entre las notificaciones locales y las notificaciones push remotas radica en su origen y en cómo se activan: 1. Las notificaciones locales se crean, programan y activan completamente en el dispositivo por la propia aplicación utilizando las API del sistema operativo (como UserNotifications en iOS o AlarmManager/WorkManager/NotificationManager en Android). Se disparan según condiciones locales del dispositivo, como una fecha u hora específica, un temporizador de cuenta regresiva o un límite geográfico (geofencing). Dado que se ejecutan localmente en el demonio del sistema operativo, no requieren un servidor backend ni una conexión activa a internet en el momento de la entrega. 2. Las notificaciones push remotas se originan en un servidor de aplicaciones externo y se transmiten a través de internet mediante pasarelas push de cada plataforma (APNs para dispositivos Apple, FCM para Android). La pasarela entrega la carga útil (payload) al demonio a nivel de sistema operativo del dispositivo, lo que despierta la aplicación o muestra un banner. Las notificaciones remotas son necesarias para eventos externos en tiempo real, como mensajes de chat entrantes, solicitudes de amistad o noticias de última hora.

let content = UNMutableNotificationContent()
content.title = "Workout Reminder"
content.body = "Time for your daily exercise routine."
content.sound = .default

// Triggers locally after 1 hour (3600 seconds) without any server interaction
let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 3600, repeats: false)
let request = UNNotificationRequest(identifier: "dailyWorkout", content: content, trigger: trigger)

UNUserNotificationCenter.current().add(request) { error in
    if let error = error {
        print("Failed to schedule notification: \(error)")
    }
}
Probar responder esta pregunta con un coach de IA

9¿Cuál es la diferencia estructural y operativa entre un Android App Bundle (.aab), un APK (paquete de Android) y un archivo IPA de iOS al distribuir aplicaciones a través de tiendas de aplicaciones?

Un APK (paquete de Android) es un formato de paquete ejecutable que contiene bytecode DEX compilado, recursos, archivos auxiliares y bibliotecas nativas que se pueden instalar y ejecutar directamente en un dispositivo Android. Un APK universal incluye recursos para todas las densidades de pantalla, arquitecturas de CPU e idiomas, lo que incrementa el tamaño de descarga. Un Android App Bundle (.aab) es un formato de subida y publicación requerido por Google Play para la distribución en la tienda. Un AAB no se puede instalar directamente en un dispositivo; en su lugar, Google Play utiliza el paquete y Play App Signing para generar APK divididos (split APKs) optimizados y adaptados dinámicamente a la arquitectura, densidad de pantalla e idioma específicos del dispositivo (Dynamic Delivery). Un IPA de iOS (.ipa) es un archivo contenedor de la aplicación (un contenedor ZIP que encierra el directorio Payload, el paquete `.app`, los recursos de firma y metadatos). Al subirse a App Store Connect, Apple realiza App Thinning (como App Slicing) para entregar únicamente los recursos y binarios necesarios para el dispositivo que realiza la descarga. Operativamente, los APK y los IPA se pueden instalar directamente en dispositivos físicos de prueba (sujeto a firmas y aprovisionamiento), mientras que un AAB debe convertirse primero en APK divididos (por ejemplo, utilizando `bundletool`) antes de su instalación en un dispositivo local.

# 1. Standalone APK installs directly via ADB
adb install myapp-universal.apk

# 2. AAB requires bundletool to generate device-tailored split APKs
bundletool build-apks --bundle=myapp.aab --output=myapp.apks --connected-device

# 3. Install the generated split APK set onto the connected device
bundletool install-apks --apks=myapp.apks
Probar responder esta pregunta con un coach de IA

10¿Qué protección ofrece TLS (seguridad de la capa de transporte) para las llamadas de red de una aplicación móvil y cómo aplican los sistemas operativos móviles modernos los valores predeterminados de transporte seguro?

TLS (seguridad de la capa de transporte) protege las llamadas de red móviles proporcionando tres garantías esenciales: confidencialidad (cifrando los datos en tránsito para que terceros no puedan leer las cargas útiles ni los encabezados), integridad de los datos (detectando cualquier alteración o modificación de solicitudes y respuestas en tránsito) y autenticación del servidor (validando el certificado digital del servidor frente a Autoridades de Certificación de confianza para prevenir ataques de intermediario (Man-in-the-Middle)). Los sistemas operativos móviles modernos aplican el transporte seguro de forma predeterminada bloqueando el tráfico HTTP no cifrado en texto plano: 1. iOS aplica App Transport Security (ATS), exigiendo que las conexiones de red (como las realizadas a través de URLSession) utilicen HTTPS con TLS 1.2+ a menos que se definan explícitamente excepciones de dominio en Info.plist. 2. Android (API 28+) deshabilita el tráfico HTTP en texto plano de forma predeterminada (`cleartextTrafficPermitted=false`). Permitir HTTP no cifrado requiere excepciones explícitas mediante la configuración de seguridad de red (`network_security_config.xml`) o el atributo del manifiesto `android:usesCleartextTraffic`.

<!-- Android: res/xml/network_security_config.xml -->
<network-security-config>
    <!-- Cleartext HTTP blocked by default. Exceptions require explicit declaration -->
    <domain-config cleartextTrafficPermitted="false">
        <domain includeSubdomains="true">api.example.com</domain>
    </domain-config>
</network-security-config>

<!-- iOS: Info.plist ATS configuration -->
<!-- ATS blocks HTTP by default; exceptions must be declared inside NSAppTransportSecurity -->
<key>NSAppTransportSecurity</key>
<dict>
    <key>NSAllowsArbitraryLoads</key>
    <false/>
</dict>
Probar responder esta pregunta con un coach de IA

Preguntas intermedias

11¿Qué papel desempeñan RTSP, RTMP y HLS en la distribución de vídeo?

RTSP controla la sesión con operaciones de preparación, reproducción y pausa; los medios suelen viajar por RTP. RTMP multiplexa medios y control en una conexión persistente y es habitual entre el emisor y el servidor de ingesta. HLS usa listas HTTP y segmentos o partes, compatibles con CDN y bitrate adaptativo. Se puede recibir RTMP, transcodificar en varias calidades, empaquetar como HLS y distribuir por HTTP; una cámara puede aportar RTSP/RTP. Son funciones habituales, no códecs ni usos exclusivos. La latencia también depende de codificación, duración de segmentos, búfer y red.

Probar responder esta pregunta con un coach de IA

12¿Cómo detectaría un punto de control DLNA que un reproductor ha dejado de estar disponible y cómo recuperaría la conexión?

Procesaría los avisos SSDP byebye y retiraría las entradas al vencer el plazo anunciado. Los fallos reiterados de transporte o de renovación de suscripciones también son indicios; un solo paquete perdido no debería borrar la selección. Marcaría el reproductor como no disponible, limitaría los comandos pendientes y repetiría el descubrimiento con esperas crecientes acotadas, teniendo en cuenta cambios de red. Al reaparecer, lo identificaría por su identificador persistente, actualizaría los puntos de acceso y renovaría las suscripciones a eventos. Consultaría el estado de reproducción antes de ofrecer continuar, pues el equipo puede haberse reiniciado u otro controlador haberlo cambiado. Solo repetiría comandos cuando fuera seguro.

Probar responder esta pregunta con un coach de IA

13Después del primer fotograma, ¿cómo puede un reproductor evitar pausas repetidas en una conexión lenta o variable?

Mediría los segundos de contenido reproducible en el búfer y la velocidad reciente de descarga de segmentos. Elegiría una variante con margen por debajo del caudal sostenible. Bajaría de calidad pronto si se vacía el búfer y la subiría con histéresis para evitar oscilaciones. Tras una pausa acumularía suficiente contenido antes de continuar. El vídeo bajo demanda admite mayor precarga; en directo hay que equilibrarla con el retraso respecto a la emisión. Ayudan la planificación de solicitudes, reutilizar conexiones y evitar descargas competidoras. Separaría el tiempo de descarga del de decodificación y mediría fotogramas perdidos, pues bajar la tasa de red puede no resolver una sobrecarga del decodificador. Evaluaría los segundos de pausa junto con calidad, tiempo de arranque y latencia en directo.

Probar responder esta pregunta con un coach de IA

14¿En qué se parecen y diferencian Weex y React Native al crear una interfaz móvil nativa desde JavaScript?

Ambos representan la interfaz mediante componentes móviles nativos, sin limitarse a mostrar una web en una WebView. Weex separa el motor de renderizado de la sintaxis y ha admitido Vue y Rax. React Native usa componentes React; su arquitectura moderna incorpora Fabric y mecanismos de integración nativa distintos del antiguo puente asíncrono. Ninguno garantiza CSS de navegador ni comportamiento idéntico en iOS y Android. Compararía versiones concretas, módulos nativos, disposición, depuración, accesibilidad y actualización según las necesidades de la aplicación. Compartir lógica de negocio evita duplicación, aunque siguen haciendo falta integraciones y componentes específicos. Un prototipo representativo permite medir el rendimiento real.

Probar responder esta pregunta con un coach de IA

15¿Cómo definirías y medirías el tiempo de arranque de una app iOS para comparar versiones?

Defino el intervalo del inicio al primer fotograma propio según el límite documentado de la herramienta y otra marca hasta interacción o contenido útil. La pantalla de lanzamiento no demuestra disponibilidad. Separo arranques de proceso de reanudaciones y casos fríos de calientes por caché y precalentamiento. Comparo compilaciones de distribución en dispositivos y sistemas equivalentes con datos, red, instalación y temperatura controlados, sin depurador que altere tiempos. Repito y publico mediana y percentiles altos. Instruments y XCTest reproducen regresiones, MetricKit u Organizer aportan distribuciones reales. Coloco signposts en inicialización, carga y creación de escenas.

Probar responder esta pregunta con un coach de IA

16¿Cómo funcionan los límites entre hilos en las llamadas a través de puentes nativos y cómo se previenen los bloqueos por salto entre hilos o las caídas de fotogramas en la interfaz de usuario (UI) cuando los módulos nativos realizan trabajo pesado en segundo plano?

Los frameworks multiplataforma utilizan convenciones de hilos específicas para las llamadas mediante puentes nativos: por ejemplo, las llamadas estándar de `MethodChannel` en Flutter llegan al hilo principal de UI de la plataforma, mientras que las llamadas tradicionales del puente de React Native se ejecutan en un hilo dedicado de JavaScript y se despachan de forma asíncrona hacia hilos nativos. Cuando un método del puente nativo se ejecuta en el hilo principal o de UI, ejecutar operaciones intensivas de CPU, operaciones síncronas prolongadas de E/S de disco o tareas bloqueantes de red detiene el bucle principal de ejecución. Esto provoca pérdida de fotogramas, tirones visibles en la UI y, en Android, errores de tipo falta de respuesta de la aplicación (ANR) o terminaciones por el watchdog en iOS. Para evitar esto, los manejadores del puente nativo deben delegar el trabajo pesado o bloqueante a grupos de ejecución en segundo plano (por ejemplo, Kotlin Coroutines con `Dispatchers.IO`/`Dispatchers.Default`, `ThreadPoolExecutor` en Android, o `Task.detached` / `DispatchQueue.global()` de GCD en Swift). Una vez finalizado el trabajo, el resultado debe enviarse de vuelta al hilo del puente esperado por el framework (por ejemplo, devolviendo resultados en el hilo de UI para MethodChannels estándar o usando colas de tareas en segundo plano), garantizando que las actualizaciones de estado multiplataforma no bloqueen el ciclo de renderizado de la UI.

class ImageProcessorPlugin : MethodChannel.MethodCallHandler {
    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())

    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
        if (call.method == "applyFilter") {
            val imageBytes = call.argument<ByteArray>("image") ?: return result.error("INVALID_ARG", "Image null", null)
            
            // Dispatch heavy computation off the main UI thread
            scope.launch {
                try {
                    val processed = processBitmapBytes(imageBytes) // CPU heavy work
                    withContext(Dispatchers.Main) {
                        result.success(processed)
                    }
                } catch (e: Exception) {
                    withContext(Dispatchers.Main) {
                        result.error("PROCESSING_FAILED", e.localizedMessage, null)
                    }
                }
            }
        } else {
            result.notImplemented()
        }
    }
}
Probar responder esta pregunta con un coach de IA

17¿Cómo diseñaría una estrategia de almacenamiento en caché e invalidación para pantallas de listas y feeds utilizando datos antiguos mientras se revalidan (Stale-While-Revalidate) y cabeceras HTTP (protocolo de transferencia de hipertexto) condicionales?

Una estrategia sólida de almacenamiento en caché e invalidación para pantallas de feeds y listas combina el patrón de mostrar datos antiguos mientras se revalidan (SWR) con cabeceras de validación condicionales de HTTP (como `ETag` / `If-None-Match` o `Last-Modified` / `If-Modified-Since`). Al abrir la pantalla, esta lee y renderiza de inmediato los datos cacheados desde una base de datos local (la fuente única de verdad, como Room o Core Data/SQLite), proporcionando una carga visual instantánea en la UI. De forma simultánea, se despacha una solicitud de red en segundo plano con la cabecera `If-None-Match: <etag>`. Si el servidor responde con `304 Not Modified`, no se transfiere ningún payload, lo que valida la caché local ahorrando ancho de banda y batería. Si el servidor responde con `200 OK`, los nuevos datos y la `ETag` actualizada se escriben en la base de datos local dentro de una transacción, y los observadores reactivos de la base de datos emiten automáticamente la lista actualizada a la UI. Para la paginación, los tokens de página o los offsets se almacenan junto con los registros en caché. La invalidación se desencadena por la expiración del tiempo de vida (TTL), acciones del usuario (como pull-to-refresh omitiendo las cabeceras condicionales) o efectos secundarios de mutaciones locales (por ejemplo, crear o eliminar un elemento localmente actualiza la base de datos de manera optimista y marca los cursores de página en caché para su revalidación).

fun getFeed(): Flow<List<FeedItem>> = flow {
    val cached = feedDao.getFeedItems()
    if (cached.isNotEmpty()) emit(cached)
    
    val lastEtag = feedDao.getFeedEtag()
    try {
        val response = api.fetchFeed(ifNoneMatch = lastEtag)
        if (response.code() == 200 && response.body() != null) {
            feedDao.updateFeedTransaction(response.body()!!, response.headers()["ETag"])
            emit(feedDao.getFeedItems())
        }
    } catch (e: Exception) {
        if (cached.isEmpty()) throw e
    }
}
Probar responder esta pregunta con un coach de IA

Preguntas avanzadas

18Una aplicación móvil financiera debe almacenar tokens de actualización de forma segura en el dispositivo, admitir desbloqueo biométrico, sobrevivir a actualizaciones del SO (sistema operativo) y operar de forma segura durante sesiones temporales fuera de línea. ¿Cómo diseñaría esta arquitectura de almacenamiento y acceso a tokens?

Almacene los tokens de actualización en iOS Keychain con políticas explícitas de accesibilidad y control de acceso biométrico, o cífrelos con una clave gestionada por Android Keystore configurada para autorización biométrica. AfterFirstUnlockThisDeviceOnly controla la accesibilidad/migración y no constituye en sí un requisito biométrico. Verifique el soporte por hardware en lugar de asumir almacenamiento en StrongBox o Secure Enclave universal. Mantenga los tokens de acceso con una vida útil corta y preferiblemente en memoria; serialice las actualizaciones y persista de forma atómica los tokens rotados. Pruebe las actualizaciones del SO, cambios en el registro biométrico, bloqueos, reinstalaciones, copia de seguridad/restauración e invalidación de claves, con una ruta de recuperación mediante reautenticación en lugar de asumir una supervivencia garantizada. El acceso fuera de línea solo debe exponer datos locales cifrados limitados bajo una política documentada, con una duración acotada y acciones en cola que se vuelvan a autorizar al reconectarse. Un cliente desconectado no puede conocer la revocación actual en el servidor, y las comprobaciones del reloj local por sí solas no constituyen una garantía sólida contra manipulaciones. Posponga la actualización de tokens y las transacciones de servidor de alto valor hasta estar en línea; revoque las sesiones del servidor afectadas y borre las credenciales/datos locales asociados tras una invalidación confirmada.

val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
val spec = KeyGenParameterSpec.Builder(
    "refreshTokenKeyAlias",
    KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
)
    .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
    .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
    .setUserAuthenticationRequired(true)
    .setUserAuthenticationParameters(0, KeyProperties.AUTH_BIOMETRIC_STRONG)
    .setInvalidatedByBiometricEnrollment(true)
    .build()
keyGenerator.init(spec)
keyGenerator.generateKey()
Probar responder esta pregunta con un coach de IA

19¿Cómo diseñaría una infraestructura de CI/CD (integración continua y despliegue continuo) escalable para un monorrepositorio móvil multiplataforma que dé soporte a múltiples equipos mientras gestiona la capacidad limitada y costosa de ejecutores (*runners*) de macOS?

Para diseñar una infraestructura de CI/CD escalable para un monorrepositorio móvil multiplataforma optimizando al mismo tiempo la capacidad escasa y costosa de macOS, la arquitectura debe basarse en la detección de compilaciones afectadas basada en grafos, una bifurcación estricta de cargas de trabajo entre flotas de ejecutores híbridos y la virtualización/orquestación efímera para macOS. En primer lugar, implemente una herramienta de grafos de compilación para monorrepositorios (como Bazel, Nx o Turborepo) con almacenamiento en caché remoto distribuido. En cada solicitud de incorporación de cambios (*pull request*), la canalización de CI calcula la diferencia del grafo acíclico dirigido (DAG) con respecto a la rama de destino para compilar y probar únicamente los paquetes afectados y sus dependientes posteriores, omitiendo por completo los módulos sin cambios. En segundo lugar, implemente una estrategia híbrida de asignación de ejecutores: delegue todas las tareas que no requieran estrictamente Xcode (como análisis de código y compilación de TypeScript/Dart, pruebas unitarias, análisis estático, escaneo de seguridad y compilaciones de Android con Gradle) a ejecutores de Linux/Kubernetes rentables y escalables. Reserve los ejecutores de macOS estrictamente para el ensamblaje final de iOS, la compilación de Swift/Objective-C, la firma de código y la ejecución de pruebas en el simulador de iOS. En tercer lugar, gestione los ejecutores de macOS mediante infraestructura de virtualización (como Tart, Anka o nodos bare-metal de AWS/MacStadium orquestados mediante Nomad o Kubernetes). Cada compilación de iOS se ejecuta en una máquina virtual limpia y efímera con cadenas de herramientas y cachés de datos derivados precalentados, lo que evita desvíos de configuración (*runner drift*) y permite un autoescalado rápido basado en la profundidad de la cola de la canalización.

name: Cross-Platform Monorepo CI
on: [pull_request]
jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      ios_affected: ${{ steps.filter.outputs.ios }}
      android_affected: ${{ steps.filter.outputs.android }}
    steps:
      - uses: actions/checkout@v4
      - id: filter
        run: |
          # Determine affected targets via monorepo tool (e.g. nx / bazel)
          echo "ios=$(./tools/affected.sh ios)" >> $GITHUB_OUTPUT
          echo "android=$(./tools/affected.sh android)" >> $GITHUB_OUTPUT

  build-android:
    needs: detect-changes
    if: needs.detect-changes.outputs.android_affected == 'true'
    runs-on: ubuntu-latest-16core
    steps:
      - uses: actions/checkout@v4
      - run: ./gradlew assembleRelease

  build-ios:
    needs: detect-changes
    if: needs.detect-changes.outputs.ios_affected == 'true'
    runs-on: macos-14
    steps:
      - uses: actions/checkout@v4
      - run: bundle exec fastlane ios build_and_test
Probar responder esta pregunta con un coach de IA

20¿Cómo diseñarías una arquitectura móvil multiplataforma para un producto que debe compartir la mayor parte de la lógica de negocio entre iOS y Android, permitiendo al mismo tiempo que la interfaz de usuario (UI), la navegación y las integraciones nativas específicas de cada plataforma evolucionen de forma independiente?

Diseñaría la aplicación en torno a un núcleo compartido que gestione el comportamiento de negocio estable: modelos de dominio, validaciones, casos de uso, reglas de negocio y contratos de acceso a datos. La UI específica de cada plataforma, la navegación, los SDKs nativos, los permisos, el manejo del ciclo de vida y las responsabilidades del shell de la aplicación deben permanecer fuera de ese núcleo. El código compartido no debe importar UIKit, SwiftUI, Jetpack, APIs del framework de Android, navegación de React Native, navegación de Flutter ni detalles de SDKs nativos. En su lugar, debe depender de interfaces estrechas como AuthRepository, SecureStorage, Analytics, CameraService o PaymentProvider que cada plataforma implementa. Organizaría el código por funcionalidad (feature) tanto como fuera posible en lugar de crear una única capa compartida monolítica. Por ejemplo, las funcionalidades de compra (checkout), búsqueda, cuenta y mensajería pueden tener su propio código compartido de dominio/casos de uso, contratos de estado e interfaces de repositorios. Los shells de iOS y Android se encargan de la composición de pantallas, patrones de UI nativos, pilas de navegación, permisos y la vinculación de adaptadores. La lógica de presentación se puede compartir cuando es verdaderamente agnóstica del framework de UI, como reducers, máquinas de estados o contratos de view-models que emiten estados y acciones simples; sin embargo, las vistas y la navegación reales deben seguir perteneciendo a cada plataforma para que puedan evolucionar de forma independiente. El compromiso principal es compartir de forma intensiva la lógica de negocio común y estable, evitando al mismo tiempo abstracciones que oculten las diferencias reales de cada plataforma. Aplicaría los límites mediante reglas de dependencias entre módulos, inyección de dependencias, APIs públicas, pruebas de contrato, comprobaciones de arquitectura y responsabilidades claras sobre el código. Las integraciones nativas deben usar puertos y adaptadores para que el código de la funcionalidad compartida vea una capacidad común mientras cada plataforma gestiona el comportamiento del SDK, el ciclo de vida, los permisos, los errores y las diferencias de UX en su propia capa.

shared-core/
  checkout/
    domain/          # Money, Cart, CheckoutRules, PlaceOrderUseCase
    ports/           # PaymentGateway, TaxRepository, Analytics
    state/           # CheckoutStateMachine or ViewModel contract

ios-app/
  checkout-ui/       # SwiftUI/UIKit screens and iOS navigation
  adapters/          # ApplePayPaymentGateway, KeychainStorage

android-app/
  checkout-ui/       # Compose/XML screens and Android navigation
  adapters/          # GooglePayPaymentGateway, EncryptedSharedPrefsStorage
Probar responder esta pregunta con un coach de IA

Practica entrevistas de Desarrollador de aplicaciones móviles en tu móvil

Responde en voz alta y recibe comentarios de la IA en la app para Android.

Descarga EngineerSpeak en Google Play
Escanea para descargar