Esta página foi traduzida pela API Cloud Translation.

Dispositivo virtual Android como plataforma de desenvolvimento

Para usar dispositivos virtuais Android (AVDs), o Android Emulator suporta uma interface gráfica do usuário (GUI) e uma interface de linha de comando (CLI). Você seleciona o fluxo de trabalho ideal para seu ambiente.

Criar e gerenciar dispositivos virtuais A GUI é uma ferramenta simples fornecida para a maioria dos desenvolvedores e usuários de aplicativos.
Iniciar o emulador a partir da linha de comando fornece uma maneira flexível para usuários avançados e automação. Por exemplo, para usar vários AVDs ou para configurar testes contínuos e integração contínua. Para começar, veja os exemplos em ferramentas ).

Inicie um AOSP Car AVD usando pré-construído

Para iniciar e testar rapidamente usando o AOSP Car AVD pré-construído, use um script de código aberto para baixar e iniciar uma versão do emulador em ci.android.com . O script foi testado em macOS e Linux.

Você precisará do Curl para usar este script.

Para executar o script:

Copie o conteúdo do script launch_emu.sh para seu arquivo local, supondo que você use launch_emu.sh como o nome do arquivo local.
Torne seu script local executável. Por exemplo, execute chmod +x ./launch_emu.sh .
Verifique as opções disponíveis executando o script com ./launch_emu.sh -h .
Em ci.android.com , vá para o branch aosp-main-throttled e selecione uma compilação recente em que sdk_car_x86_64 esteja verde. Por exemplo, 11370359. Se você não vir as informações de compilação, saia da sua Conta do Google e tente novamente.
Baixe e instale os arquivos binários relevantes para o emulador com o ID de compilação. Por exemplo, ./launch_emu.sh -i -a 11370359 .
Depois disso, você pode usar ./launch_emu.sh para iniciar o emulador baixado e instalado (não use as opções -i ou -a ).
Para baixar e instalar outro ID de compilação, execute ./launch_emu.sh -c para limpar seu espaço de trabalho e repita a Etapa 4 e a Etapa 5 acima.

Para especificar as opções de inicialização da linha de comando do emulador Android ao iniciar o emulador, use a opção -v . Por exemplo:

  ./launch_emu.sh -v “-cores 4 -memory 6144 -no-snapshot"

Construa um AVD de carro AOSP

O processo para construir um AVD de carro AOSP é semelhante ao de construir imagens AVD para um telefone (por exemplo, aosp_car_x86_64):

Para configurar o ambiente de desenvolvimento e identificar uma ramificação, consulte Ferramentas de controle de origem . Em seguida, revise Baixando a fonte :

ANDROID_BRANCH="android12L-release"

REPO_URL="https://android.googlesource.com/platform/manifest"

mkdir $ANDROID_BRANCH && cd $ANDROID_BRANCH && repo init -u $REPO_URL -b
$ANDROID_BRANCH --partial-clone &&  repo sync -c -j8

Construa a imagem AVD:

. build/envsetup.sh && lunch sdk_car_x86_64-userdebug && m -j32

Execute a imagem AVD (anexe opções adicionais de inicialização de linha de comando conforme necessário):
```
emulator &
```
Por exemplo:
Figura 1. Tela do Android Virtual Emulator
Notas sobre este processo:
- Como o processo de compilação é o mesmo necessário para compilar o Android para um dispositivo físico, reserve algum tempo para baixar o código-fonte e, em seguida, compilá-lo.
- Para trabalhar em outras ramificações, defina $ANDROID_BRANCH para outra ramificação/tag .
- Imagens AVD, como system.img , são criadas em $ANDROID_PRODUCT_OUT . Para saber mais sobre imagens principais, consulte Diretório do sistema AVD .
- Consulte o arquivo README para saber como os binários do emulador pré-construídos em sua árvore Android são usados para executar o emulador.

Crie um AVD de carro

Adicionar um AVD de carro novo é quase idêntico a Adicionar um novo dispositivo . Por exemplo, 1660554 cria um novo AVD avd_car .

Para criar um AVD de carro:

Crie uma empresa e uma pasta de dispositivo conforme necessário. Este exemplo usa $ANDROID_BUILD_TOP/device/google_car/avd_car .
Crie o makefile do produto, avd_car.mk , que define como construir o AVD.
Crie uma pasta de dispositivo, avd_car_device , na qual conterá BoardConfig.mk e source.properties .
Adicione o novo makefile e a nova opção lunch ao AndroidProducts.mk .

Para construir e executar o novo AVD avd_car :

. build/envsetup.sh && lunch acar-userdebug && m -j32 && emulator &

Agora você está pronto para prototipar a maioria dos recursos de IHM e aplicativos em seu novo AVD.

Compacte um arquivo zip de imagem AVD

Você pode compactar e compartilhar seu AVD com outras pessoas ou usá-lo em outro computador. Use emu_img_zip.mk para gerar o arquivo zip da imagem AVD:

Depois de construir o AVD, faça emu_img_zip o destino:
```
m emu_img_zip
```
O arquivo zip da imagem AVD, prefixado com sdk-repo-linux-system-images , é criado na pasta chamada $ANDROID_PRODUCT_OUT .
Observação: embora emu_img_zip.mk tenha sido adicionado após o Android 11, você pode adaptar o makefile para uma versão anterior. Por exemplo, 1661582 funciona com Android 11.

Construa um kernel AVD

Os kernels AVD são semelhantes a outros kernels Android, pois todos são imagens pré-construídas. Normalmente, você pode usar as imagens pré-construídas do kernel goldfish padrão, como em cada versão do Android.

Para experimentar as alterações do kernel:

Execute a seguinte série de instruções:

mkdir goldfish-kernel-54
cd goldfish-kernel-54
repo init -u https://android.googlesource.com/kernel/manifest -b
common-android11-5.4
repo sync
BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh
BUILD_CONFIG=common-modules/virtual-device/build.config.goldfish.x86_64
build/build.sh
ls -l ./out/android11-5.4/dist/

Substitua o binário do kernel na base de código de acordo com o makefile do AVD. Por exemplo, x86_64-vendor.mk inclui x86_64-kernel.mk .

O código e a configuração do kernel estão localizados da seguinte forma:

Item	Valor
Filial	`common-android11-5.4` (usado no Android 11)
Manifesto	`kernel/manifest/common-android11-5.4`
módulos comuns/dispositivo virtual	`kernel/common-modules/virtual-device/android11-5.4`
Núcleo	`kernel/common/android11-5.4`

Crie um novo perfil de dispositivo

Para permitir que os usuários criem um AVD específico no Android Studio AVD Manager, consulte Criar e gerenciar dispositivos virtuais . Os fabricantes de dispositivos podem definir suas próprias especificações de hardware, como tamanho de tela e DPI, por meio do uso de um arquivo devices.xml incluído na imagem AVD.

Por exemplo, consulte os perfis de dispositivos automotivos em automotive.xml .
Para desenvolvimento ou prototipagem de IHM, vários dispositivos podem ser adicionados ao arquivo para a mesma imagem AVD.
Inclua o arquivo no arquivo zip da imagem OEM AVD na pasta [ABI] . Por exemplo, como x86_64 .
Os fabricantes de dispositivos também podem criar uma capa de emulador . Por exemplo, para definir botões de hardware adicionais para UX de maior fidelidade. Isso não é útil apenas para fluxos de trabalho de desenvolvedores, mas também para outras tarefas, como pesquisa e revisão de UX.

Crie o arquivo XML da imagem AVD

Os fabricantes de dispositivos podem criar um arquivo XML de imagem AVD para o Android Studio fazer download.

Por exemplo, consulte o arquivo XML de imagem AAOS AVD, sys-img2-1.xml .
Os fabricantes de dispositivos podem definir seu próprio contrato de licença OEM AVD para seus usuários-alvo (empregando o sistema honorário), com a licença para Android Emulator. O Android Studio obtém consenso do usuário quando tal licença é incluída.

Para criar a imagem:

Prepare um arquivo zip de imagem AVD.
Descompacte ${ANDROID_PRODUCT_OUT}/sdk-repo-linux-system-images-*.zip .
Adicione devices.xml à pasta x86_64 e compacte o arquivo em um arquivo zip. Por exemplo, como oem_avd_img_x86_64.zip .
Atualize oem-sys-img2-1.xml .
Atualize o nome, o tamanho e o shasum do arquivo zip (exemplos de arquivos XML são fornecidos em tools ).

Por exemplo, para hospedar o AVD no Google Cloud Storage , consulte Criando buckets de armazenamento .

Para fazer upload e tornar o AVD acessível publicamente, consulte Tornando os dados públicos :

BUCKET_NAME="aaos-avd"
gsutil mb gs://$BUCKET_NAME
gsutil cp oem_avd_img_x86_64.zip gs://$BUCKET_NAME
gsutil cp oem-sys-img2-1.xml gs://$BUCKET_NAME
gsutil iam ch allUsers:objectViewer gs://$BUCKET_NAME

O formato do URL do complemento do SDK de imagem AVD é: https://storage.googleapis.com/$BUCKET_NAME/oem-sys-img2-1.xml . Por exemplo, se BUCKET_NAME for aaos-avd, o URL será: https://storage.googleapis.com/aaos-avd/oem-sys-img2-1.xml .

Para que seus usuários possam baixar imagens AVD e usar seu AVD do Android Studio, você pode fornecer um arquivo XML complementar do SDK. Para obter detalhes, consulte Atualizar as ferramentas IDE e SDK .

Para baixar o AVD da rede:

Hospede o arquivo zip de imagem e os arquivos XML em um servidor.
Forneça o URL aos usuários-alvo.
( Opcional ) Limite o acesso por nome de usuário e senha.

Alternativamente, para acelerar o desenvolvimento, baixe o AVD em um diretório local:

Salve os arquivos XML e todos os artefatos especificados no arquivo XML em uma pasta (por exemplo, todos os arquivos zip de imagem AVD) chamada ADDON_DIR .
Especifique a URL como file://$ADDON_DIR/oem-sys-img2-1.xml .