Capítulo 2: Preparación del Dispositivo Android para Appium

18 de enero de 2025 Por: Artiko

appiumandroidusbadbdepuracióndriversdispositivo

Capítulo 2: Preparación del Dispositivo Android para Appium

Este capítulo te guiará paso a paso en la preparación de tu dispositivo Android físico para trabajar con Appium. Aprenderás a habilitar las opciones necesarias, instalar drivers USB y verificar que todo funcione correctamente.

🎯 Objetivos del Capítulo

Al finalizar este capítulo podrás:

✅ Habilitar opciones de desarrollador y depuración USB
✅ Instalar drivers USB específicos del fabricante
✅ Conectar y autorizar el dispositivo
✅ Verificar la conexión con ADB
✅ Solucionar problemas comunes de conexión

📱 Paso 1: Habilitar Opciones de Desarrollador

Android 4.2 y Superior

// Proceso para habilitar Developer Options
fun enableDeveloperOptions() {
    // 1. Abrir Configuración/Settings
    openSettings()
    
    // 2. Navegar según versión Android:
    when (androidVersion) {
        >= 9.0 -> "Acerca del teléfono → Información del software"
        >= 8.0 -> "Sistema → Acerca del teléfono"
        else -> "Acerca del dispositivo"
    }
    
    // 3. Tocar 7 veces sobre "Número de compilación"
    repeat(7) {
        tap("Número de compilación")
    }
    
    // 4. Mensaje: "Ahora eres desarrollador"
}

Ubicación por Fabricante

Samsung:
  Path: Ajustes → Acerca del teléfono → Información del software
  Tap: Número de compilación (7 veces)

Xiaomi/Redmi/POCO:
  Path: Ajustes → Acerca del teléfono
  Tap: Versión MIUI (7 veces)
  Note: Puede requerir cuenta Mi

OnePlus:
  Path: Ajustes → Acerca del teléfono
  Tap: Número de compilación (7 veces)

Pixel/Google:
  Path: Ajustes → Acerca del teléfono
  Tap: Número de compilación (7 veces)

Huawei:
  Path: Ajustes → Sistema → Acerca del teléfono
  Tap: Número de compilación (7 veces)

Motorola:
  Path: Ajustes → Sistema → Acerca del teléfono
  Tap: Número de compilación (7 veces)

🔓 Paso 2: Activar Depuración USB

Configuración Básica

// Opciones esenciales para automatización
const developerSettings = {
  // Ubicación: Ajustes → Opciones de desarrollador
  
  "Depuración USB": true,              // OBLIGATORIO
  "Instalación vía USB": true,         // Recomendado
  "Verificar apps por USB": false,     // Desactivar
  "Permitir ubicaciones simuladas": true, // Para testing GPS
  
  // Configuración de pantalla
  "Mantener pantalla activa": true,    // Evita bloqueos
  "Mostrar toques": true,              // Útil para debug
  
  // Animaciones (acelerar tests)
  "Escala de animación de ventana": 0.5,
  "Escala de animación de transición": 0.5,
  "Escala de duración del animador": 0.5
};

Pasos Detallados

Abrir Opciones de Desarrollador:

# Via ADB (si ya está conectado)
adb shell am start -n com.android.settings/.DevelopmentSettings

# O manualmente:
# Ajustes → Sistema → Avanzado → Opciones de desarrollador

Activar Depuración USB:

// Toggle "Depuración USB/USB Debugging"
Settings.Developer.USB_DEBUGGING = true

// Aparecerá advertencia de seguridad
// Tap: "Aceptar" o "OK"

Configuraciones Adicionales Recomendadas:

// Para evitar problemas durante testing
const additionalSettings = {
  // Seguridad
  "Desbloqueo OEM": false,  // Solo si no necesitas
  
  // Red
  "Depuración inalámbrica": false,  // USB es más estable
  "ADB sobre red": false,           // Por seguridad
  
  // Energía
  "No apagar pantalla": true,       // Durante carga USB
  
  // Permisos
  "Deshabilitar permisos": false,   // Mantener activo
  "Forzar apps redimensionables": true  // Para tablets
};

🔌 Paso 3: Instalación de Drivers USB

Windows - Drivers Específicos

# Opción 1: Google USB Driver (genérico)
# En Android Studio: SDK Manager → SDK Tools → Google USB Driver

# Opción 2: Drivers del fabricante

Enlaces de Descarga por Fabricante

Samsung:
  URL: https://developer.samsung.com/mobile/android-usb-driver.html
  Installer: SAMSUNG_USB_Driver_for_Mobile_Phones.exe
  
Xiaomi:
  URL: https://developer.android.com/studio/run/win-usb
  Note: Usar Mi PC Suite o drivers genéricos
  
OnePlus:
  URL: https://www.oneplus.com/support/softwareupdate
  Installer: OnePlus_USB_Drivers_Setup.exe
  
LG:
  URL: https://www.lg.com/us/support/software-firmware-drivers
  Installer: LGMobileDriver.exe
  
Motorola:
  URL: https://motorola-global-portal.custhelp.com/app/answers/detail/a_id/88481
  Installer: Motorola_Mobile_Drivers.exe
  
Huawei:
  URL: https://consumer.huawei.com/en/support/hisuite/
  Note: HiSuite incluye drivers
  
Google/Pixel:
  URL: https://developer.android.com/studio/run/win-usb
  Installer: latest_usb_driver_windows.zip

Instalación Manual en Windows

# 1. Conectar dispositivo
# 2. Abrir Administrador de dispositivos
devmgmt.msc

# 3. Buscar dispositivo con signo de exclamación
# 4. Click derecho → Actualizar controlador
# 5. Buscar software de controlador en el equipo
# 6. Seleccionar carpeta con drivers descargados

# Verificar instalación
adb devices

macOS - Configuración

# macOS detecta automáticamente dispositivos Android
# No requiere drivers adicionales

# Si hay problemas, instalar Android File Transfer
brew install --cask android-file-transfer

# Verificar detección
system_profiler SPUSBDataType | grep -i android

Linux - Reglas udev

# Crear archivo de reglas para tu dispositivo
sudo nano /etc/udev/rules.d/51-android.rules

# Agregar línea según fabricante (ver tabla abajo)
# Formato: SUBSYSTEM=="usb", ATTR{idVendor}=="XXXX", MODE="0666", GROUP="plugdev"

# Ejemplos por fabricante:

# /etc/udev/rules.d/51-android.rules
# Google
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"
# Samsung
SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", MODE="0666", GROUP="plugdev"
# Xiaomi
SUBSYSTEM=="usb", ATTR{idVendor}=="2717", MODE="0666", GROUP="plugdev"
# OnePlus
SUBSYSTEM=="usb", ATTR{idVendor}=="2a70", MODE="0666", GROUP="plugdev"
# Motorola
SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", MODE="0666", GROUP="plugdev"
# LG
SUBSYSTEM=="usb", ATTR{idVendor}=="1004", MODE="0666", GROUP="plugdev"
# Huawei
SUBSYSTEM=="usb", ATTR{idVendor}=="12d1", MODE="0666", GROUP="plugdev"
# Sony
SUBSYSTEM=="usb", ATTR{idVendor}=="0fce", MODE="0666", GROUP="plugdev"
# OPPO
SUBSYSTEM=="usb", ATTR{idVendor}=="22d9", MODE="0666", GROUP="plugdev"

# Aplicar cambios
sudo chmod a+r /etc/udev/rules.d/51-android.rules
sudo udevadm control --reload-rules
sudo service udev restart

# Agregar usuario al grupo plugdev
sudo usermod -aG plugdev $USER

# Logout y login para aplicar cambios

🔐 Paso 4: Autorización del Dispositivo

Primera Conexión

# 1. Conectar dispositivo por USB
# 2. En el dispositivo aparecerá:
# "¿Permitir depuración USB?"
# "La huella digital de la clave RSA del equipo es: XX:XX:XX..."

# 3. Marcar: "Permitir siempre desde este ordenador"
# 4. Tap: "Aceptar"

# Verificar conexión
adb devices
# Output esperado:
# List of devices attached
# ABC123DEF456    device

Gestión de Claves RSA

# Ver claves autorizadas en el dispositivo
adb shell cat /data/misc/adb/adb_keys

# Revocar autorizaciones
# En dispositivo: Opciones de desarrollador → Revocar autorizaciones de depuración USB

# Ubicación de clave en el PC
# Windows: %USERPROFILE%\.android\adbkey.pub
# macOS/Linux: ~/.android/adbkey.pub

✅ Paso 5: Verificación con ADB

Comandos Básicos de Verificación

# Listar dispositivos conectados
adb devices -l
# Output detallado:
# ABC123DEF456   device product:ginkgo model:Redmi_Note_8 device:ginkgo transport_id:1

# Información del dispositivo
adb shell getprop ro.product.model
adb shell getprop ro.product.manufacturer
adb shell getprop ro.build.version.release
adb shell getprop ro.build.version.sdk

# Estado de la batería
adb shell dumpsys battery

Script de Verificación Completa

// check-device.js
const { exec } = require('child_process');
const util = require('util');
const execPromise = util.promisify(exec);

async function checkDevice() {
  console.log('📱 Verificando dispositivo Android...\n');
  
  try {
    // Verificar ADB
    const { stdout: adbVersion } = await execPromise('adb version');
    console.log('✅ ADB instalado:', adbVersion.split('\n')[0]);
    
    // Listar dispositivos
    const { stdout: devices } = await execPromise('adb devices');
    const deviceList = devices.split('\n')
      .filter(line => line.includes('device') && !line.includes('List'))
      .map(line => line.split('\t')[0]);
    
    if (deviceList.length === 0) {
      console.log('❌ No hay dispositivos conectados');
      console.log('\nVerifica:');
      console.log('1. Cable USB conectado');
      console.log('2. Depuración USB activada');
      console.log('3. Dispositivo autorizado');
      return;
    }
    
    console.log(`✅ Dispositivos encontrados: ${deviceList.length}`);
    
    // Info de cada dispositivo
    for (const device of deviceList) {
      console.log(`\n📱 Dispositivo: ${device}`);
      
      // Modelo
      const { stdout: model } = await execPromise(
        `adb -s ${device} shell getprop ro.product.model`
      );
      console.log(`   Modelo: ${model.trim()}`);
      
      // Android version
      const { stdout: version } = await execPromise(
        `adb -s ${device} shell getprop ro.build.version.release`
      );
      console.log(`   Android: ${version.trim()}`);
      
      // API Level
      const { stdout: sdk } = await execPromise(
        `adb -s ${device} shell getprop ro.build.version.sdk`
      );
      console.log(`   API Level: ${sdk.trim()}`);
      
      // Estado
      const { stdout: state } = await execPromise(
        `adb -s ${device} get-state`
      );
      console.log(`   Estado: ${state.trim()}`);
    }
    
    console.log('\n✅ Dispositivo listo para Appium!');
    
  } catch (error) {
    console.error('❌ Error:', error.message);
  }
}

checkDevice();

🛠️ Paso 6: Configuración Avanzada

Múltiples Dispositivos

# Listar todos los dispositivos
adb devices

# Ejecutar comando en dispositivo específico
adb -s ABC123DEF456 shell pm list packages

# Variables de entorno para dispositivo por defecto
export ANDROID_SERIAL=ABC123DEF456

WiFi ADB (Opcional)

# Android 11+ tiene ADB inalámbrico integrado

# 1. Conectar por USB primero
adb tcpip 5555

# 2. Obtener IP del dispositivo
adb shell ip addr show wlan0

# 3. Conectar por WiFi
adb connect 192.168.1.100:5555

# 4. Desconectar USB

# 5. Verificar conexión WiFi
adb devices

# Volver a USB
adb usb

Configuración de Permisos Automáticos

// auto-grant-permissions.js
async function setupPermissions(deviceId) {
  const permissions = [
    'android.permission.CAMERA',
    'android.permission.ACCESS_FINE_LOCATION',
    'android.permission.RECORD_AUDIO',
    'android.permission.READ_EXTERNAL_STORAGE',
    'android.permission.WRITE_EXTERNAL_STORAGE'
  ];
  
  const packageName = 'com.example.app';
  
  for (const permission of permissions) {
    await exec(`adb -s ${deviceId} shell pm grant ${packageName} ${permission}`);
  }
}

🔧 Troubleshooting Común

Problema: “unauthorized” en adb devices

# Solución 1: Re-autorizar
adb kill-server
adb start-server
adb devices
# Aceptar prompt en el dispositivo

# Solución 2: Limpiar claves
# En PC:
rm ~/.android/adbkey*
# En dispositivo:
# Opciones desarrollador → Revocar autorizaciones USB
# Reconectar y autorizar

Problema: “device not found”

# Windows: Verificar drivers
devmgmt.msc
# Buscar "Android Device" o dispositivo con ⚠️

# Linux: Verificar permisos
ls -la /dev/bus/usb/
lsusb | grep -i android

# Todos OS: Cambiar cable USB
# Usar puerto USB 2.0 en lugar de 3.0
# Probar cable original del dispositivo

Problema: “more than one device/emulator”

// Especificar dispositivo en Appium capabilities
const caps = {
  platformName: 'Android',
  'appium:automationName': 'UiAutomator2',
  'appium:udid': 'ABC123DEF456',  // Específico device ID
  'appium:deviceName': 'Pixel 4',   // Descriptivo
};

Problema: Dispositivo se desconecta

Causas comunes:
  Cable defectuoso:
    - Usar cable de datos, no solo carga
    - Cable original recomendado
  
  Modo de energía:
    - Desactivar optimización de batería
    - Mantener pantalla activa
  
  Puerto USB:
    - Cambiar de puerto
    - Evitar hubs USB
    - Usar USB 2.0 si hay problemas con 3.0
  
  Configuración OEM:
    - Samsung: Desactivar Knox
    - Xiaomi: Desactivar optimizaciones MIUI
    - Huawei: Permitir HiSuite

📊 Información del Dispositivo para Capabilities

Obtener Información Necesaria

# Script para obtener toda la info necesaria
cat > device-info.sh << 'EOF'
#!/bin/bash
echo "📱 Información del Dispositivo"
echo "=============================="
echo "UDID: $(adb get-serialno)"
echo "Modelo: $(adb shell getprop ro.product.model)"
echo "Fabricante: $(adb shell getprop ro.product.manufacturer)"
echo "Android Version: $(adb shell getprop ro.build.version.release)"
echo "API Level: $(adb shell getprop ro.build.version.sdk)"
echo "Arquitectura: $(adb shell getprop ro.product.cpu.abi)"
echo "Resolución: $(adb shell wm size | cut -d' ' -f3)"
echo "Densidad: $(adb shell wm density | cut -d' ' -f3)"
EOF

chmod +x device-info.sh
./device-info.sh

Capabilities para Appium

// Basado en la info obtenida
const capabilities = {
  platformName: 'Android',
  'appium:platformVersion': '12',           // ro.build.version.release
  'appium:deviceName': 'Redmi Note 8',      // ro.product.model
  'appium:udid': 'ABC123DEF456',           // adb get-serialno
  'appium:automationName': 'UiAutomator2',
  'appium:noReset': true,
  'appium:fullReset': false,
  'appium:newCommandTimeout': 300,
  
  // Opcionales pero útiles
  'appium:systemPort': 8200,  // Para múltiples dispositivos
  'appium:skipServerInstallation': false,
  'appium:skipDeviceInitialization': false,
  'appium:ignoreHiddenApiPolicyError': true,
  'appium:disableWindowAnimation': true
};

🎯 Ejercicio Práctico

Verificación Completa del Dispositivo

// full-device-check.js
const { exec } = require('child_process');
const util = require('util');
const execPromise = util.promisify(exec);

class DeviceChecker {
  async checkAll() {
    console.log('🔍 Iniciando verificación completa...\n');
    
    const checks = [
      this.checkADB(),
      this.checkDevice(),
      this.checkDeveloperOptions(),
      this.checkPackages(),
      this.checkConnectivity()
    ];
    
    await Promise.all(checks);
    console.log('\n✅ Verificación completa!');
  }
  
  async checkADB() {
    try {
      await execPromise('adb version');
      console.log('✅ ADB funcionando');
    } catch (e) {
      console.log('❌ ADB no encontrado');
    }
  }
  
  async checkDevice() {
    try {
      const { stdout } = await execPromise('adb devices');
      if (stdout.includes('\tdevice')) {
        console.log('✅ Dispositivo conectado');
      } else {
        console.log('❌ No hay dispositivos');
      }
    } catch (e) {
      console.log('❌ Error verificando dispositivos');
    }
  }
  
  async checkDeveloperOptions() {
    try {
      const { stdout } = await execPromise(
        'adb shell settings get global development_settings_enabled'
      );
      if (stdout.trim() === '1') {
        console.log('✅ Opciones de desarrollador activas');
      } else {
        console.log('⚠️ Opciones de desarrollador inactivas');
      }
    } catch (e) {
      console.log('❌ No se pudo verificar opciones');
    }
  }
  
  async checkPackages() {
    try {
      const { stdout } = await execPromise(
        'adb shell pm list packages | grep -c package'
      );
      console.log(`✅ Packages instalados: ${stdout.trim()}`);
    } catch (e) {
      console.log('❌ Error listando packages');
    }
  }
  
  async checkConnectivity() {
    try {
      const { stdout } = await execPromise(
        'adb shell ping -c 1 google.com'
      );
      if (stdout.includes('1 received')) {
        console.log('✅ Conectividad a Internet');
      }
    } catch (e) {
      console.log('⚠️ Sin conectividad a Internet');
    }
  }
}

new DeviceChecker().checkAll();

📋 Checklist Final

### ✅ Dispositivo Listo para Appium

- [ ] Opciones de desarrollador habilitadas
- [ ] Depuración USB activada
- [ ] Instalación vía USB permitida
- [ ] Dispositivo autorizado (RSA key)
- [ ] Drivers USB instalados (Windows)
- [ ] Reglas udev configuradas (Linux)
- [ ] ADB detecta el dispositivo
- [ ] Pantalla configurada para no apagarse
- [ ] Animaciones reducidas/desactivadas
- [ ] Cable USB de datos (no solo carga)
- [ ] Puerto USB funcionando correctamente
- [ ] Sin aplicaciones de seguridad bloqueando

📚 Resumen

Has preparado exitosamente tu dispositivo Android para automatización con Appium:

✅ Opciones de desarrollador activadas
✅ Depuración USB configurada
✅ Drivers instalados según tu OS
✅ Dispositivo autorizado y conectado
✅ ADB funcionando correctamente
✅ Configuración optimizada para testing

🚀 Próximo Paso

Con el dispositivo listo, ahora configuraremos el driver UiAutomator2 para comenzar a automatizar.

👉 Continuar con Capítulo 3: Configuración del Driver UiAutomator2

Tip: Si trabajas con múltiples dispositivos, crea un script que automatice estas configuraciones para ahorrar tiempo en futuros setups.