android emulator container scripts
1.0.0
Este es un conjunto de scripts mínimos para ejecutar el emulador en un contenedor para varios sistemas como Docker, para consumo externo. Los scripts son compatibles con Python versión 2 y 3.
*Tenga en cuenta que esta sigue siendo una característica experimental y recomendamos instalar esta herramienta en un entorno virtual de Python. Por favor, presente problemas si nota que algo no funciona como se esperaba.
Estas demostraciones están destinadas a ejecutarse en un sistema operativo Linux. Su sistema debe cumplir con los siguientes requisitos:
Se debe instalar un intérprete de Python (Python3 con Python3-Venv para crear entornos virtuales)
ADB debe estar disponible en el camino. ADB viene como parte de Th Thidroid SDK. Tenga en cuenta que instalar las herramientas de línea de comando es suficiente.
Docker debe estar instalado. Asegúrese de poder ejecutarlo como usuario no raíz
Docker-Compose debe estar instalado.
KVM debe estar disponible. Puede obtener acceso a KVM ejecutando "Bare Metal", o en una máquina (virtual) que proporciona una virtualización anidada. Si planea ejecutar esto en la nube (GCE/Azure/AWS/etc.), primero debe asegurarse de tener acceso a KVM. Los detalles sobre cómo obtener acceso a KVM en los diversos proveedores de la nube se pueden encontrar aquí:
Tenga en cuenta que verá un rendimiento reducido si está utilizando la virtualización anidada. Los contenedores han sido probados bajo Debian y Ubuntu ejecutando el kernel 5.2.17.
Nota: Las imágenes no se ejecutarán en Docker en Mac o Windows
Ahora organizamos un conjunto de contenedores en un repositorio público. Puede encontrar detalles sobre los contenedores aquí. Ahora puede ejecutar estos contenedores sin construirlos. Por ejemplo:
docker run
-e ADBKEY= " $( cat ~ /.android/adbkey ) "
--device /dev/kvm
--publish 8554:8554/tcp
--publish 5555:5555/tcp
us-docker.pkg.dev/android-emulator-268719/images/30-google-x64:30.1.2Esto reducirá el contenedor si no está disponible localmente y lo lanzará. Puedes ver que está comenzando:
Después de esto, puede conectarse al dispositivo configurando ADB:
adb connect localhost:5555El dispositivo ahora debería aparecer después de un tiempo como:
$ adb devices
List of devices attached
localhost:5555 deviceSi desea usar esto en un script, puede hacer lo siguiente:
docker run -d
-e ADBKEY= " $( cat ~ /.android/adbkey ) "
--device /dev/kvm
--publish 8554:8554/tcp
--publish 5555:5555/tcp
us-docker.pkg.dev/android-emulator-268719/images/30-google-x64:30.1.2
adb connect localhost:5555
adb wait-for-device
# The device is now booting, or close to be booted
Se puede encontrar un script más detallado en run-in-script-exame.sh.
Puede instalar el paquete Python de la siguiente manera:
source ./configure.sh
Esto activará un entorno virtual y pondrá a disposición el emu-docker ejecutable. Puede obtener información detallada sobre el uso lanzándolo de la siguiente manera:
emu-docker -h
Tendrá que aceptar los acuerdos de licencia antes de poder crear contenedores Docker.
Puede seleccionar interactivamente qué versión de Android y emulador desea usar ejecutando:
emu-docker interactive --start
Se le pedirá que seleccione una imagen del sistema y una versión de emulador, después de lo cual se creará un archivo Docker. La imagen y el emulador del sistema se descargarán al directorio actual si es necesario. El script le proporcionará un comando para ver los registros, así como el comando para detener el contenedor.
Si el servidor ADB local detectó el contenedor iniciado automáticamente, no tiene nada que hacer para consultarlo a través de ADB. Si ese no es el caso, ahora puede conectarse al dispositivo en ejecución usando ADB:
adb connect localhost:5555
Para verificar si ADB ha visto el contenedor, puede usar:
adb devices
Comando y verifique si se detecta un dispositivo.
¡No olvide detener el contenedor Docker una vez que haya terminado!
Lea la sección sobre cómo hacer que el emulador esté disponible en la web para ejecutar el emulador usando WebRTC
Emisor:
emu-docker list
consultará las URL de salida y SDK de Android publicadas actualmente para los archivos zip de:
Para cada imagen del sistema, se muestran el nivel API, la variante, ABI y URL. Para cada emulador, se muestran el canal de actualización (estable vs canario), la versión, el sistema operativo host y la URL.
Salida de ejemplo:
SYSIMG android 21 L x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-21_r05.zip
SYSIMG android 22 L x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-22_r06.zip
SYSIMG android 23 M x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-23_r10.zip
SYSIMG android 24 N x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-24_r08.zip
SYSIMG android 25 N x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-25_r01.zip
SYSIMG android 26 O x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-26_r01.zip
SYSIMG android 27 O x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-27_r01.zip
SYSIMG android 28 P x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-28_r04.zip
SYSIMG android 28 Q x86_64 https://dl.google.com/android/repository/sys-img/android/x86_64-Q_r04.zip
SYSIMG google_apis 21 L x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-21_r30.zip
SYSIMG google_apis 22 L x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-22_r24.zip
SYSIMG google_apis 23 M x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-23_r31.zip
SYSIMG google_apis 24 N x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-24_r25.zip
SYSIMG google_apis 25 N x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-25_r16.zip
SYSIMG google_apis 26 O x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-26_r13.zip
SYSIMG google_apis 28 P x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-28_r09.zip
SYSIMG google_apis 28 Q x86_64 https://dl.google.com/android/repository/sys-img/google_apis/x86_64-Q_r04.zip
SYSIMG google_apis_playstore 28 P x86_64 https://dl.google.com/android/repository/sys-img/google_apis_playstore/x86_64-28_r08.p
SYSIMG google_apis_playstore 28 Q x86_64 https://dl.google.com/android/repository/sys-img/google_apis_playstore/x86_64-Q_r04.zp
EMU stable 29.0.11 windows https://dl.google.com/android/repository/emulator-windows-5598178.zip
EMU stable 29.0.11 macosx https://dl.google.com/android/repository/emulator-darwin-5598178.zip
EMU stable 29.0.11 linux https://dl.google.com/android/repository/emulator-linux-5598178.zip
EMU stable 28.0.25 windows https://dl.google.com/android/repository/emulator-windows-5395263.zip
EMU canary 29.0.12 windows https://dl.google.com/android/repository/emulator-windows-5613046.zip
EMU canary 29.0.12 macosx https://dl.google.com/android/repository/emulator-darwin-5613046.zip
EMU canary 29.0.12 linux https://dl.google.com/android/repository/emulator-linux-5613046.zip
Luego se puede usar herramientas como wget o un navegador para descargar un emulador deseado y una imagen del sistema. Después de obtener los dos, podemos construir una imagen Docker.
Dado un archivo zip emulador y un archivo zip de imagen del sistema, podemos crear un directorio que se pueda enviar a docker build a través de la siguiente invocación de emu-docker :
emu-docker create <emulator-zip> <system-image-zip> [--dest docker-src-dir
(getcwd()/src by default)]
Esto coloca todos los elementos correctos para ejecutar una imagen de Docker, pero aún no construye, ejecuta o publica. Se debe utilizar un archivo zip de emulador de Linux.
Para construir la imagen Docker correspondiente a estos emuladores e imágenes del sistema:
docker build <docker-src-dir, either ./src or specified argument to
emu_docker.py>
Saltará una ID de imagen Docker; Guarde esta ID de imagen.
Actualmente suponemos que KVM se utilizará con Docker para proporcionar capacidades de virtualización de CPU a la imagen de Docker resultante.
Proporcionamos el siguiente script de ejecución:
./run.sh <docker-image-id> <additional-emulator-params>
Hace lo siguiente:
docker run -e ADBKEY="$(cat ~/.android/adbkey)"
--device /dev/kvm
--publish 8554:8554/tcp
--publish 5555:5555/tcp <docker-image-id>
--device /dev/kvm para tener aceleración de la CPUNota: Puede usar un publickkey público inyectando la variable ADBKEY_PUB, es decir: -e ADBKEY_PUB = "$ (CAT/.Android/ADBKEY.PUB)"
También tiene la opción de montar una partición A /Data que el emulador usará si está disponible. Esto le permite usar un TMPFS que puede dar un mayor rendimiento, especialmente en el escenario de virtualización anidada.
Por ejemplo:
docker run -e ADBKEY="$(cat ~/.android/adbkey)"
--device /dev/kvm
--mount type=tmpfs,destination=/data
--publish 8554:8554/tcp
--publish 5555:5555/tcp <docker-image-id>
Actualmente solo admitimos la aceleración de hardware para NVIDIA. Para utilizar la aceleración de hardware, es posible que deba instalar las extensiones de Nvidia Docker desde aquí si está ejecutando una versión anterior de Docker (<19.03). Debe asegurarse de tener una instalación X mínima si está utilizando una instancia en la nube. Por ejemplo, se puede usar XVFB. Debe construir los contenedores pasando en la bandera - -GPU:
emu-docker create stable Q --gpu
Ahora puede iniciar el emulador con el script run-with-gpu.sh :
./run-with-gpu.sh <docker-image-id> <additional-emulator-params>
El script es similar al descrito anteriormente con la adición de que lo hará:
--gpu all )La aceleración de hardware mejorará significativamente el rendimiento de las aplicaciones que dependen en gran medida de los gráficos. Tenga en cuenta que a pesar de que necesitamos un servidor X11 para la aceleración de GPU, no se mostrará UI.
Puede llevar las imágenes creadas a un repositorio proporcionando los parámetros - -Push y - -Repo y - -Tag al crear una imagen. El parámetro -gag es opcional y se usa para indicar la versión de la imagen creada. Esto será predeterminado al ID de construcción del emulador, ya que las imágenes del sistema rara vez se actualizan.
Adoptamos el siguiente esquema de nombres para imágenes:
{API}-{sort}-{abi}
Dónde:
Por ejemplo: 29-PlayStore-X86: 30.1.2 indica una imagen del sistema habilitada para PlayStore con Q que se ejecuta en 32 bits X86.
Una invocación de ejemplo para publicar todas las imágenes Q en Google Cloud Repo podría ser:
emu-docker -v create --push --repo us.gcr.io/emulator-project/ stable " Q "Las imágenes que se han llevado a un repositorio se pueden iniciar directamente desde el repositorio. Por ejemplo:
docker run --device /dev/kvm --publish 8554:8554/tcp --publish 5555:5555/tcp
us.gcr.io/emulator-project/29-playstore-x86:30.1.2Reenviamos el puerto 5555 para el acceso ADB al emulador que se ejecuta dentro del contenedor. ADB podría no detectar automáticamente el dispositivo, así que ejecute:
adb connect localhost:5555
Su dispositivo ahora debería aparecer como:
$ adb devices
List of devices attached:
localhost:5555 deviceEste repositorio también contiene un ejemplo que demuestra cómo puede usar Docker para que el emulador sea accesible a través de la web. Esto se hace componiendo el siguiente conjunto de contenedores Docker:
Para ejecutar esta muestra y poder interactuar con el emulador, debe tener lo siguiente en mente:
Necesitará Docker-compuesto.
Debe tener el puerto 80 y 443 disponible. Los contenedores Docker crearán una red interna y expondrán los puertos HTTP y HTTPS.
Deberá crear una imagen de Docker del emulador, como se describe en la documentación anterior.
Dependiendo de su red, es posible que necesite girar
Actualmente estamos utilizando Firebase para manejar la autenticación y la autorización. Deberá proporcionar una configuración JSON del proyecto que desea utilizar. Puede usar la muestra proporcionada aquí, pero solo funcionará en localhost. Puede obtener la configuración de Firebase desde la consola, coloque la configuración de Firebase Josn aquí:
./js/firebase_config.json
Esto se utilizará para generar la configuración y la configuración de envío.
Para crear los contenedores web, debe tener las siguientes herramientas disponibles:
A continuación, debe crear un contenedor con la versión de imagen de emulador y sistema que desea utilizar. Por ejemplo:
. ./configure.sh && emu-docker create canary "P.*x86_64"
Una vez que haya cuidado los pasos anteriores, puede crear los contenedores utilizando el script create_web_container.sh :
$ ./create_web_container.sh -h
usage: create_web_container.sh [-h] [-a] [-s] [-i] -p user1,pass1,user2,pass2,...
optional arguments:
-h show this help message and exit.
-a expose adb. Requires ~ /.android/adbkey.pub to be available at run.
-s start the container after creation.
-i install systemd service, with definition in /opt/emulatorPor ejemplo:
./create_web_container.shEsto hará lo siguiente:
Ahora puede iniciar el contenedor de la siguiente manera:
docker-compose -f js/docker/docker-compose.yaml upSi desea hacer que el ADB esté disponible, puede aplicar la superposición encontrada en JS/Docker/Development.yaml de la siguiente manera:
docker-compose -f js/docker/docker-compose.yaml -f js/docker/development.yaml upApunte su navegador al localhost. Es probable que obtenga una advertencia debido al uso del certificado autoinfirmado. Una vez que acepte el certificado, debería poder iniciar sesión y comenzar a usar el emulador.
Tenga en cuenta las siguientes cosas cuando haga que el emulador sea accesible sobre ADB:
~/.android/adbkey . Esta es la clave privada utilizada por ADB. Sin esto, no podrá acceder al dispositivo a través de ADB.adb connect ip-address-of-container:5555 antes de que pueda interactuar con el dispositivo. Por ejemplo: $ adb connect localhost:5555
$ adb shell getpropHay un script de muestra de nube de nube que proporciona detalles sobre cómo puede configurar una instancia que se iniciará y configurará automáticamente un emulador en la creación. Los detalles sobre cómo hacer esto se pueden encontrar aquí.
Tenemos un documento separado relacionado con el tratamiento de problemas.
Los detalles sobre el diseño y cómo modificar la aplicación React se pueden encontrar aquí
