Depurar aplicaciones Android en Windows con AMD

En este artículo, voy a apartar un poco la temática general del blog, que es la arquitectura de software, para hablar sobre un problema reciente que he tenido y la solución que encontré.

Hace unas semanas decidí comprar una nueva laptop aprovechando una temporada de ofertas, hacía mucho que no renovada mí equipo y estaba realmente impaciente. Uno de mis principales objetivos era iniciarme en la programación en Android (con Android Studio). Había tenido algunos acercamientos previos, no profesionales, pero esta vez desea poner en serio manos en el asunto.

Vi una laptop de la que me enamore, tenía una memoria impresionante, un procesador más que decente y una tarjeta gracia aceptable, aparte de un teclado y monitores bastante cómodos. Solo había un problema, tenía un micro AMD.

Había oído que los procesadores AMD era muy lentos a la hora de ejecutar aplicaciones en el emulador de Android, pero me dije “¡Ba!, ¿Qué tal lento puede ser, con esta máquina?”. Así que me la lleve a casa. Todo iba como la seda, rapidísimo, hasta que probé el dichoso emulador. Era lento, muy lento… Ridículamente lento. El emulador tardaba horas en arrancar, ¡Horas! Y cuando arranco, no se podía hacer nada, cada movimiento era extremadamente tedioso.

En este punto podía hacer varias cosas [1]:

• Devolver la laptop, pero ¡Me gustaba mucho!
• Comprar una solución de pago, como Genymotion, pero no desea gasta más dinero y menos tener que realizar un poco anual.
• Compra un o varios dispositivo móvil, y debugear en ellos, pero ¡Ey, me acabo de comprar una laptop, no estoy para derrochar!
• Buscar algún otro emulador (gratuito), que funcione correctamente.

La solución que encontré fue combinar android-x86, un sistema operativo para pc, basado en Android, y Virtual Box (un sistema para gestionar maquinas virtuales). Con ambos sistemas conseguí tener un emulador rápido que se acoplaba perfectamente a Android Studio.

Estos son los pasos para montar un emulador con Android-x86 y Virtual Box.

Habilitar las capacidades de virtualización de tu equipo

Tanto AMD, como Intel, tiene capacidades de virtualización para acelerar el uso de máquinas virtuales, pero por defecto vienen, casi siempre, apagadas. Aunque no es necesario, si es muy recomendable que las habilites para el emulador vaya más rápido.

Conseguir el software

Puedes bajar el android-x86 del siguiente enlace, yo tengo android-x86_64-6.0-r1.iso (Marshmallow), aunque puedes usar la imagen que más te convenga:

http://www.android-x86.org/download

Android Studio puedes descargarlo de:

https://developer.android.com/studio/index.html

Y por último Virtual Box

https://www.virtualbox.org/

Procede a Instalar la maquina Android Studio y Virtual Box

Crea un maquina virtual para Android-x86

Inicia Virtual Box y crea una nueva máquina virtual que contenga Android-x86. Para lo cual haz clic, en “Nuevo”, y proporciona la siguiente información:

• Nombre: “Emulador Android”
• Tipo: Linux
• Versión: Other Linux (64 bits)
• Memoria: Yo seleccione 1204 Megas, pero ajústalo a tus necesidades y capacidades.
• Disco duro: Deje el recomendado de 8 gigas.

Y continúa el proceso hasta finalizar.

Inicia la máquina, cuando te pregunte el disco de arranque indícale el archivo ISO que descargaste (en mi caso android-x86_64-6.0-r1.iso)

Nos mostrara el menú inicial, seleccionaremos

Installation – Install Android-x86 to harddisk

A continuación iremos seleccionando las siguientes opciones:

Create/Modify partitions

Do you want to use GPT, indicaremos que no.

Nos aparecerá el menú de particiones del disco virtual, seleccionaremos las siguientes opciones:

New -> Primary

Seleccionaremos Bootable.

Después Write y por ultimo quit.

Seleccionaremos la partición creada, normalmente sda1, y la formateamos como ext4 (confirmarnos el formateo).

Indicaremos que queremos instalar GRUB (yes), que no queremos instalar EFI (skip).

Indicaremos que quedemos nuestra directorio /system de lectura y escritura.

Se procederá a copiar los archivos.

Iniciar la maquina

Una vez realizada la instalación, debemos arrancar el sistema y configurarlo como si fuera un dispositivo Android cualquiera (con cuenta de Gmail y demás).

La primera ejecución puede llegar a ser un poco lenta (varios minutos), pero las siguientes serán aproximadamente, como iniciar un teléfono móvil (si no es que mas rápido).

Por cierto, el sistema de integración del ratón, no es automático, tenemos que seleccionar la opción “integración del ratón”, dentro del menú “Entrada”, cada vez que iniciemos la maquina y usar la tecla <HOST > (por defecto control derecho) para liberar el puntero de la máquina virtual.

Configurar las dimensiones de un teléfono móvil

Al momento de iniciar nuestro nuevo sistema operativo Android, veremos que tiene el aspecto de un monitor, más ancho que alto. El sistema tiene varias resoluciones y todas cumplen ese patrón.

Para poder usar resoluciones propias de un teléfono, es decir más alto que ancho, tenemos que modificar el arranque de nuestro sistema, además de indicar a nuestra máquina virtual que soporte dichas resoluciones.

Las resoluciones que recomiendo para emular un dispositivo móvil, son las siguientes:

• 320x480
• 480x800
• 768x1280
• 1080x1920

Para hacer posible que la máquina virtual reconozca estas resoluciones, hay que ejecutar en una ventana de cmd, los siguientes comandos (con la maquina virtual apagada):

VBoxManage setextradata "Emulador Android" "CustomVideoMode1" "320x480x16"
VBoxManage setextradata "Emulador Android" "CustomVideoMode2" "480x800x16"
VBoxManage setextradata "Emulador Android" "CustomVideoMode3" "768x1280x16"
VBoxManage setextradata "Emulador Android" "CustomVideoMode4" "1080x1920x16"

Ya que estén habilitadas estas resoluciones, iniciamos nuestra máquina, pulsando en la ventana de inicio de GRUB, la tecla ‘e’, para editar la línea de arranque. En la segunda pantalla, la volvemos a pulsar para entrar en el editor.

Debemos dirigirnos al final de la línea de arranque y agregar la configuración vga=ask. Guardamos y iniciamos la maquina, con la tecla ‘b’, para pulsar enter cuando nos lo solicite.

Aquí vemos la las opciones de resolución posible (para ver más escribimos ‘scan’):

Es necesario apuntar, los números de “Mode” que corresponde a cada resolución nueva, en mi caso son los cuatro últimos y son los siguientes:

Modo	Dimensiones
360	320x480
361	480x800
362	768x1280
363	1080x1920

Estos números están en Hexadecimal, a partir de ahora necesitaremos los mismo números pero en decimal, para convertirlos, puedes usar, por ejemplo, esta página http://www.binaryhexconverter.com/hex-to-decimal-converter

Los valores de mis pantallas en decimal quedarían así:

Dimensiones	Hexadecimal	decimal
320x480	360	864
480x800	361	865
768x1280	362	866
1080x1920	363	867

Apunta bien esos valores por que los vas a necesitar en la sección siguiente

Configurar GRUB, para arrancar en diversas resoluciones

Una vez que tenemos los mencionados números de las resoluciones, debemos configurar GRUB, para arrancar una u otra. Para ello, debemos crear nuevas entraras en su archivo de configuración.

Para poder modificarlo debemos seleccionar, en el arranque de la máquina virtual “Android-x86 6.0-r1 (Debug mode)” (o el modo debug que aparezca) en el menú de inicio. Se nos habilitara un Shell donde podremos escribir comandos (posiblemente tengamos que pulsar enter antes de comenzar a escribir):

Los pasos a completar son:

Localizar el archivo menu.lst, en mi caso está en /mnt/grub/.

cd /mnt/grub

Lo editamos con vi:

vi menu.lst

Tendrá una apariencia como esta:

Nuestro objetivo es que acabe con las siguientes entradas:

default=0
timeout=6
splashimage=/grub/android-x86.xpm.gz
root (hd0,0)

title Android-x86 6.0-r1
kernel /android-6.0-r1/kernel quiet root=/dev/ram0 androidboot.hardware=android_x86_64 SRC=/android-6.0-r1
initrd /android-6.0-r1/initrd.img

title Android-x86 6.0-r1 320x480x32
kernel /android-6.0-r1/kernel quiet root=/dev/ram0 androidboot.hardware=android_x86_64 SRC=/android-6.0-r1 vga=864
initrd /android-6.0-r1/initrd.img

title Android-x86 6.0-r1 480x800x32
kernel /android-6.0-r1/kernel quiet root=/dev/ram0 androidboot.hardware=android_x86_64 SRC=/android-6.0-r1 vga=865
initrd /android-6.0-r1/initrd.img

title Android-x86 6.0-r1 768x1280x32
kernel /android-6.0-r1/kernel quiet root=/dev/ram0 androidboot.hardware=android_x86_64 SRC=/android-6.0-r1 vga=866
initrd /android-6.0-r1/initrd.img

title Android-x86 6.0-r1 1080x1920x32
kernel /android-6.0-r1/kernel quiet root=/dev/ram0 androidboot.hardware=android_x86_64 SRC=/android-6.0-r1 vga=867
initrd /android-6.0-r1/initrd.img


title Android-x86 6.0-r1 (Debug mode)
kernel /android-6.0-r1/kernel root=/dev/ram0 androidboot.hardware=android_x86_64 DEBUG=2 SRC=/android-6.0-r1
initrd /android-6.0-r1/initrd.img

title Android-x86 6.0-r1 (Debug nomodeset)
kernel /android-6.0-r1/kernel nomodeset root=/dev/ram0 androidboot.hardware=android_x86_64 DEBUG=2 SRC=/android-6.0-r1
initrd /android-6.0-r1/initrd.img

title Android-x86 6.0-r1 (Debug video=LVDS-1:d)
kernel /android-6.0-r1/kernel video=LVDS-1:d root=/dev/ram0 androidboot.hardware=android_x86_64 DEBUG=2 SRC=/android-6.0-r1
initrd /android-6.0-r1/initrd.img

Tenemos que agregar nuevas configuraciones basadas en la primera y agregar el atributo vga=<valor de nuestra pantalla> por ejemplo vga=865, siendo el numero indicado, el valor en decimal, que se obtuvo en las pantalla de seleccionar resolución (estando en dicha pantalla en hexadecimal).

Para editar un archivo en vi, tenemos los siguientes comandos

Tecla	Efecto	Ejemplo
Esc	Permite introducir comandos
I	Comienza una inserción
dd	Borra una línea completa
Nyy	Copia N líneas al portapapeles	10yy
p	Pega las líneas del portapapeles
:wq	Salva el archivo y sale

A partir de ahora cuando iniciemos nuestra máquina virtual podremos seleccionar la resolución deseada

Ajustar la resolución

Cuando iniciemos la aplicación, nos daremos cuenta que la resolución de Android, es mayor que nuestro monitor, con lo que aparecerán unas scrollbar con la que nos podemos desplazar, lo cual es bastante incómodo.

Para solucionarlo, podemos pulsar la tecla <HOST>+C, hará que sea redimensionable la ventana de Android, con el nuevo problema que se verá con un “aspecto” raro:

Para solucionarlo dimensiona la ventana de la pantalla, fijándote que la figura central quede circular, con eso obtendrás la resolución deseada. Tómalo como referencia, siempre que cambies el tamaño de la pantalla.

Por otro lado el posible que pierdas frecuentemente el uso del ratón, para recuperarlo pulsa <HOST>+c y activa la integración del ratón, para luego volver a pulsar <HOST> + C y volver a la resolución deseada.

Configura la red

La configuración que yo tengo en la red de la máquina virtual de Android es “Adaptador puente”, si tienes por necesidad otra, ve a esta página ver configuraciones adicionales http://www.android-x86.org/documents/debug-howto

¡Vamos a debugear!

Ya casi hemos llegado…

Este es el único paso que vas a tener que hacer cada vez que quieras debugear tu aplicaciones (y hayas reiniciado tu maquina).

Necesitas “conectar” tu maquina física con la máquina virtual Android, para lo cual necesitas conocer la IP de dicha máquina.

En una terminal de Android, teclea ifconfig, y apunta la IP, que te va a dar (suele ser siempre la misma si así configuras tu router, por si más adelante quieres hacer un Shell).

Una vez que tengas dicha IP, en tu máquina de Windows, teclea el comando

adb connect <IP de la máquina de Android>

¡Listo!, ahora podemos iniciar nuestro Android Studio, y comenzar a depurar.

---

[1] Otra opción no expuesta es usar el emulador en Linux, donde se comparta de forma nativa, con un muy buen rendimiento, prueba que es lo mejor para ti y elije lo que más te convenga.