Pruebas en dispositivo físico

Los simuladores son rápidos; los dispositivos físicos son veraces. La depuración por USB e inalámbrica conectan tu app de SDK 57 al hardware real, y la distribución interna envía compilaciones instalables a QA sin revisión de App Store - el ciclo que todo equipo móvil necesita antes de producción.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

# Android USB - verifica que el dispositivo sea visible
adb devices
# Esperado: <serial>    device
 
# Ejecuta una compilación de desarrollo directamente en el teléfono conectado
npx expo install expo-dev-client
npx expo run:android --device
 
# iOS USB - selecciona el iPhone conectado en Xcode o:
npx expo run:ios --device
 
# Inicia Metro para un dev client instalado (misma Wi-Fi o USB)
npx expo start --dev-client --lan
 
# Depuración inalámbrica de Android (Android 11+) después del emparejamiento USB inicial
adb pair <ip>:<pairing-port>    # una sola vez, desde Opciones de Desarrollador
adb connect <ip>:5555
adb devices
 
# Compilación QA interna (instalable .ipa / .apk)
eas build --profile preview --platform all

Cuándo usarlo:

• Validación de cámara, biometría, notificaciones push o háptica que los simuladores falsifican u omiten.
• Medición del rendimiento de desplazamiento y memoria en SoCs reales.
• QA necesita una compilación instalable sin lanzamiento público en la tienda.
• Depuración de problemas de LAN - USB (--localhost / adb reverse) evita Wi-Fi inestable.
• Dogfooding de un candidato a lanzamiento en los teléfonos de compañeros a través de TestFlight o pruebas internas de Play.

Ejemplo de trabajo

#!/usr/bin/env bash
# scripts/qa-device-session.sh - verificación USB, compilación de desarrollo, compilación interna de vista previa
set -euo pipefail
 
PLATFORM="${1:-android}"   # android | ios
 
echo "▶ Verificando expo-dev-client…"
npx expo install expo-dev-client
 
if [[ "$PLATFORM" == "android" ]]; then
  echo "▶ Dispositivos Android:"
  adb devices
  if ! adb devices | grep -w device | grep -v "List of devices" >/dev/null; then
    echo "❌ Ningún dispositivo Android en estado 'device'. Habilita la depuración USB y acepta el mensaje RSA."
    exit 1
  fi
  npx expo run:android --device
  npx expo start --dev-client --lan
else
  echo "▶ Dispositivos iOS (requiere Xcode):"
  xcrun xctrace list devices 2>/dev/null || instruments -s devices
  npx expo run:ios --device
  npx expo start --dev-client --lan
fi

// eas.json - desarrollo (diario) + vista previa (distribución QA interna)
{
  "cli": { "version": ">= 16.0.0" },
  "build": {
    "development": {
      "developmentClient": true,
      "distribution": "internal",
      "android": { "gradleCommand": ":app:assembleDebug" },
      "ios": { "simulator": false }
    },
    "preview": {
      "distribution": "internal",
      "channel": "preview",
      "android": { "buildType": "apk" },
      "ios": { "simulator": false }
    }
  }
}

# Después de que existe eas.json:
eas login
eas build:configure   # si no se ha hecho ya
 
# Desarrollo diario en tu teléfono
eas build --profile development --platform android
# Instala desde el código QR/enlace, luego:
npx expo start --dev-client
 
# Entregar a QA - distribución interna (sin revisión de tienda)
eas build --profile preview --platform ios
eas build --profile preview --platform android
# iOS → grupo interno de TestFlight; Android → APK directo o pista interna de Play

// App.tsx - muestra el modo de conexión para que QA pueda informar del entorno con precisión
import { useEffect, useState } from "react";
import { StyleSheet, Text, View } from "react-native";
import * as Device from "expo-device";
import Constants from "expo-constants";
 
export default function App() {
  const [info, setInfo] = useState("Cargando…");
 
  useEffect(() => {
    const model = Device.modelName ?? "unknown";
    const os = `${Device.osName} ${Device.osVersion}`;
    const build = Constants.expoConfig?.version ?? "0.0.0";
    const channel = Constants.expoConfig?.extra?.eas?.channel ?? "local";
    setInfo(`${model} · ${os} · v${build} · channel:${channel}`);
  }, []);
 
  return (
    <View style={styles.container}>
      <Text style={styles.title}>Sonda de dispositivo QA</Text>
      <Text style={styles.body}>{info}</Text>
      <Text style={styles.hint}>Agita el dispositivo - menú de desarrollo - Recarga después de que Metro se reconecte.</Text>
    </View>
  );
}
 
const styles = StyleSheet.create({
  container: { flex: 1, justifyContent: "center", alignItems: "center", padding: 24 },
  title: { fontSize: 20, fontWeight: "700", marginBottom: 8 },
  body: { fontSize: 14, textAlign: "center", color: "#334155" },
  hint: { marginTop: 16, fontSize: 12, color: "#64748b" },
});

Lo que esto demuestra:

• adb devices como la puerta antes de implementaciones Android USB.
• npx expo run:android --device / npx expo run:ios --device para compilaciones nativas locales en hardware.
• Perfiles eas.json separando desarrollo (dev client + debug) de vista previa (QA interna).
• Metadatos de expo-device en pantalla para que los reportes de errores incluyan modelo y SO.

Profundización

Cómo funciona

• La depuración USB expone el dispositivo a adb (Android) o devicectl/ios-deploy de Xcode (iOS). Expo CLI y npx expo run:* reenvían el bundle de Metro sobre la conexión.
• npx expo start --dev-client sirve JavaScript a una compilación de desarrollo instalada - el shell nativo permanece en el teléfono; JS hot recarga sobre LAN, túnel o reenvío de puerto USB.
• La depuración inalámbrica mantiene la misma URL de Metro después de emparejar una vez - Android usa adb pair + adb connect; iOS usa emparejamiento inalámbrico de Xcode Window > Devices and Simulators (flujo de iOS 17+ en Xcode 15+).
• La distribución interna (distribution: "internal" en eas.json) produce IPAs ad-hoc de iOS (dispositivos registrados) o APKs de Android / cargas de pista interna de Play - no listados públicos en la tienda.
• El canal de vista previa se combina bien con EAS Update para que QA pueda recibir bundles OTA de JS después de que el shell nativo está instalado.

Configuración USB de Android

# Reversa de puerto USB - dispositivo llega a localhost de la computadora portátil (funciona cuando LAN está bloqueada)
adb reverse tcp:8081 tcp:8081
npx expo start --dev-client --localhost

Configuración USB de iOS

Las Apple IDs gratuitas pueden implementarse en tu propio dispositivo para pruebas limitadas; la distribución de equipo requiere una membresía del Programa de Desarrolladores de Apple.

Depuración inalámbrica

Después de adb connect inalámbrico, ejecuta npx expo start --dev-client --lan y asegúrate de que el teléfono y la computadora portátil compartan una subred (la Wi-Fi de invitados a menudo bloquea el tráfico entre pares).

Perfiles de distribución interna

# Registra dispositivos de prueba de iOS antes de compilaciones ad-hoc/internas de iOS
eas device:create
 
# Envía compilación de vista previa de iOS a probadores internos de TestFlight
eas build --profile preview --platform ios
eas submit --platform ios --latest

Modos de conexión para Metro

Notas de TypeScript

import * as Device from "expo-device";
 
if (__DEV__ && Device.isDevice) {
  console.log(`Dispositivo físico: ${Device.modelName}, SO ${Device.osVersion}`);
}

Instala con npx expo install expo-device - las versiones se alinean con SDK 57 automáticamente.

Errores comunes

• adb devices muestra unauthorized - El mensaje RSA fue descartado. Solución: Revoca autorizaciones de depuración USB en el teléfono, vuelve a conectar USB, acepta el mensaje.
• Compilación de iOS falla con errores de aprovisionamiento - UDID del dispositivo no está en el perfil. Solución: Ejecuta eas device:create y recompila, o registra el dispositivo en el portal de Desarrolladores de Apple.
• Metro inalcanzable en LAN - Las redes de invitados bloquean tráfico entre dispositivo y computadora portátil. Solución: Usa adb reverse + --localhost en Android, o --tunnel en ambas plataformas.
• Expo Go en dispositivo no coincide con SDK 57 - Expo Go de App Store puede quedarse atrás de tu SDK de proyecto. Solución: Usa una compilación de desarrollo; Expo Go no puede cargar módulos nativos arbitrarios de todos modos.
• adb inalámbrico se cae silenciosamente - El teléfono se durmió o cambió de IP. Solución: adb connect de nuevo; mantén habilitada la depuración inalámbrica en Opciones de Desarrollador.
• Compilación interna de iOS no se instala - Dispositivo de probador no registrado. Solución: Recopila UDIDs a través de enlace eas device:create antes de compilaciones de preview.
• QA prueba rendimiento de depuración - Las compilaciones de depuración incluyen sobrecarga de herramientas de desarrollo. Solución: Envía compilaciones preview o release para aprobación de rendimiento.

Alternativas

Preguntas frecuentes

adb devices

eas device:create

Relacionado

• iOS Simulator & Android Emulator - dispositivos virtuales rápidos para trabajo de diseño diario
• expo-dev-client - menú de desarrollo, lanzador e iteración de módulos nativos en dispositivo
• Local Development Basics - túnel vs LAN cuando el dispositivo no puede llegar a Metro
• Expo Go vs Development Builds - cuándo Expo Go en un teléfono sigue siendo suficiente
• Environments & EAS Environment Variables - URLs de API de staging en compilaciones de vista previa
• Internal Distribution - pistas ad hoc, empresa y tienda interna

Versiones de pila: Esta página fue escrita para React 19.2.3, React Native 0.86.0, y Expo SDK 57 (expo ~57.0.4).