O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Testar o desenvolvimento para Android

Este tutorial permite conhecer o desenvolvimento do sistema operacional Android pela primeira vez.

Configuração para desenvolvimento em Android

Antes de baixar e criar a ramificação main da origem do Android, confira se o hardware atende aos requisitos e se o software necessário está instalado corretamente. Você também precisa conhecer estes termos:

Git: O Git é um sistema de controle de versões distribuído, de código aberto e gratuito. O Android usa o Git para operações locais, como ramificações, commits, diferenças e edições. Para aprender a usar o Git, consulte a documentação relevante (em inglês).
Repo: Repo é um wrapper Python baseado no Git que simplifica a execução de operações complexas em vários repositórios Git. O Repo não substitui o Git para todas as operações de controle de versões, apenas facilita operações complexas do Git. Ele usa arquivos de manifesto para agregar projetos do Git no superprojeto do Android.
Arquivo de manifesto: Um arquivo de manifesto é um arquivo XML que especifica onde os vários projetos Git na origem do Android são posicionados na árvore de origem do AOSP.

Atender aos requisitos de hardware

Sua estação de trabalho de desenvolvimento precisa atender ou exceder estes requisitos de hardware:

Um sistema x86 de 64 bits.

Observação: você pode compilar versões AOSP anteriores à 2.3.x em sistemas de 32 bits.
Pelo menos 400 GB de espaço livre em disco para verificar e criar o código (250 GB para verificar + 150 GB para criar).

Observação: se você estiver verificando um espelho, precisará de mais espaço, já que os espelhos completos do Android Open Source Project (AOSP) contêm todos os repositórios Git que já foram usados.
Mínimo de 64 GB de RAM. O Google usa máquinas de 72 núcleos com 64 GB de RAM para criar para o Android. Com essa configuração de hardware, um build completo do Android leva aproximadamente 40 minutos e um build incremental apenas alguns minutos. Por outro lado, leva aproximadamente 6 horas para um build completo com uma máquina de 6 núcleos com 64 GB de RAM.

Atender aos requisitos do sistema operacional

Sua estação de trabalho de desenvolvimento precisa executar uma distribuição de Linux de 64 bits com a biblioteca GNU C (glibc) 2.17 ou mais recente.

Instalar os pacotes necessários

Para instalar os pacotes necessários para Ubuntu 18.04 ou mais recente, execute este comando:

sudo apt-get install git-core gnupg flex bison build-essential zip curl zlib1g-dev libc6-dev-i386 x11proto-core-dev libx11-dev lib32z1-dev libgl1-mesa-dev libxml2-utils xsltproc unzip fontconfig

Instalar o software necessário

Antes de poder trabalhar com AOSP, você precisa instalar o OpenJDK, Make, Python 3 e Repo. A principal ramificação AOSP do Android vem com versões pré-criadas do OpenJDK, Make e Python 3. Etapas extra de instalação não são necessárias. A seção abaixo explica como instalar o Repo.

Instalar o Repo

Siga estas etapas para instalar o Repo:

Faça o download das informações do pacote atual:
```
sudo apt-get update
```
Execute o comando abaixo para instalar o inicializador do Repo:
```
sudo apt-get install repo
```
O inicializador do Repo fornece um script Python que faz o download e a instalação da ferramenta do Repo completa.

Se isso der certo, pule para a etapa 4.

(opcional) Instale manualmente o Repo usando estes comandos:

export REPO=$(mktemp /tmp/repo.XXXXXXXXX)
curl -o ${REPO} https://storage.googleapis.com/git-repo-downloads/repo
gpg --recv-keys 8BB9AD793E8E6153AF0F9A4416530D5E920F5C65
curl -s https://storage.googleapis.com/git-repo-downloads/repo.asc | gpg --verify - ${REPO} && install -m 755 ${REPO} ~/bin/repo

Os três primeiros comandos configuram um arquivo temporário, fazem o download do Repo para o arquivo e verificam se a chave fornecida corresponde à chave necessária. Se os comandos tiverem sucesso, o comando final vai instalar o inicializador do Repo.

Confira a versão do inicializador do Repo:
```
repo version
```
A saída precisa indicar a versão 2.4 ou mais recente. Por exemplo:

repo launcher version 2.45

Baixar a origem do Android

A origem do Android fica em uma coleção de repositórios Git hospedados pelo Google. Cada repositório Git inclui todo o histórico do Android, incluindo mudanças na origem e quando elas foram feitas. Para baixar a origem do Android, siga estas etapas:

Navegue até o diretório principal:
```
cd ~
```
Crie um subdiretório de trabalho local dentro dele:
```
mkdir aosp
```
Navegue até o diretório:
```
cd aosp
```

Inicialize a ramificação main do código-fonte do repositório AOSP (o padrão):

repo init --partial-clone -b main -u https://android.googlesource.com/platform/manifest

Insira ou aceite suas credenciais do Git (nome, endereço de e-mail).
Sincronize o código-fonte:
```
repo sync -c -j8
```
Se tiver problemas durante o download, consulte Solucionar e resolver problemas de sincronização.

Criar o código

Para criar o código, siga estas etapas:

No diretório de trabalho, crie o script envsetup.sh para configurar seu ambiente de build:
```
source build/envsetup.sh
```

Especifique um tipo de dispositivo de destino e use o comando lunch para criação. Um destino é uma permutação do dispositivo, como um modelo ou formato específico. Especifique este destino:

lunch aosp_cf_x86_64_phone-trunk_staging-userdebug

Você vai ver uma sinopse do destino e do ambiente de build:

============================================
PLATFORM_VERSION_CODENAME=VanillaIceCream
PLATFORM_VERSION=VanillaIceCream
PRODUCT_INCLUDE_TAGS=com.android.mainline
TARGET_PRODUCT=aosp_arm
TARGET_BUILD_VARIANT=eng
TARGET_ARCH=arm
TARGET_ARCH_VARIANT=armv7-a-neon
TARGET_CPU_VARIANT=generic
HOST_OS=linux
HOST_OS_EXTRA=Linux-6.5.13-1rodete2-amd64-x86_64-Debian-GNU/Linux-rodete
HOST_CROSS_OS=windows
BUILD_ID=AOSP.MAIN
OUT_DIR=out
============================================

Crie o destino:
```
m
```

A conclusão do primeiro build leva horas. Os próximos builds levam muito menos tempo. A saída do seu build aparece em $OUT_DIR.

Iniciar o Cuttlefish

O Cuttlefish é o emulador do Android usado para testar seus builds.

Execute os comandos abaixo para baixar, criar e instalar os pacotes host do Debian:

sudo apt install -y git devscripts equivs config-package-dev debhelper-compat golang curl
git clone https://github.com/google/android-cuttlefish
cd android-cuttlefish
for dir in base frontend; do
pushd $dir
# Install build dependencies
sudo mk-build-deps -i
dpkg-buildpackage -uc -us
popd
done
sudo dpkg -i ./cuttlefish-base_*_*64.deb || sudo apt-get install -f
sudo dpkg -i ./cuttlefish-user_*_*64.deb || sudo apt-get install -f
sudo usermod -aG kvm,cvdnetwork,render $USER
sudo reboot

A reinicialização aciona a instalação de outros módulos do kernel e aplica as regras udev.

Inicie o Cuttlefish:
```
launch_cvd --daemon
```
Conecte o dispositivo Cuttlefish acessando https://localhost:8443 no navegador da Web. Seu dispositivo virtual com tecnologia Android será mostrado.

Fazer uma mudança

Atualize o código-fonte de acordo com esta lista de mudanças.

Na raiz do checkout (diretório aosp/), navegue até o projeto frameworks/native do Git:
```
cd frameworks/native
```
Inicie um projeto temporário com este comando:
```
repo start <some-name> .
```

Use o editor para editar SurfaceFlinger.cpp neste local:

aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

Encontre esta linha:

void SurfaceFlinger::updateColorMatrixLocked() {

No início de updateColorMatrixLocked(), adicione esta linha:

mClientColorMatrix = mat4(vec4{1.0f, 0.0f, 0.0f, 0.0f}, vec4{0.0f, -1.0f, 0.0f, 0.0f},
                          vec4{0.0f, 0.0f, -1.0f, 0.0f}, vec4{0.0f, 1.0f, 1.0f, 1.0f});

Crie o código:
```
m
```

Atualize o build no dispositivo:

adb root
adb remount -R
adb root
adb sync
adb reboot

Confira se você nota uma mudança de cor no dispositivo selecionado parecida com o mostrado na Figura 1.

Figura 1. Aparência da tela após a mudança de cor.

Corrigir um teste

Esta parte do codelab usa um exemplo de teste que está na árvore de origem e que apresenta falha.

Para executar, depurar e corrigir o teste, siga estas instruções:

Execute:
```
atest DevCodelabTest
```
O teste vai falhar.

Observação: atest é uma ferramenta de linha de comando que permite criar, instalar e executar testes do Android localmente.

Examine o stack trace do teste com falha:

STACKTRACE:
java.lang.AssertionError
 at org.junit.Assert.fail(Assert.java:87)
 at org.junit.Assert.assertTrue(Assert.java:42)
 at org.junit.Assert.assertTrue(Assert.java:53)
 at android.test.example.devcodelab.DevCodelabTest.testHelloWorld(DevCodelabTest.java:29)

A última linha do stack trace mostra o teste com falha (testHelloWorld). Esse teste está em um arquivo chamado DevCodelabTest.java.

Para determinar a localização do teste que precisa de correção, adicione WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/ à última linha do stack trace até (e incluindo) o nome do arquivo de teste. Assim, android.test.example.devcodelab.DevCodelabTest se torna WORKING_DIRECTORY/platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java.
Edite platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java e substitua Assert.assertTrue(false) por Assert.assertTrue(true).
Execute o teste de novo para conferir se o problema foi corrigido:
```
atest DevCodelabTest
```

Fazer upload do código para revisão

O Repo simplifica o uso do Git porque agrupa comandos como git clone para funcionar em vários repositórios Git (ou projetos) de uma só vez.

Para a análise de código dos seus projetos no Git, use o sistema de revisão de código baseado na Web, Gerrit (link em inglês).

Depois de ter feito as mudanças no projeto frameworks/native, execute estes comandos para fazer upload delas:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```

Na mensagem de commit, insira o seguinte:

Android codelab change
Test: manual atest

Faça upload da sua mudança:

repo upload

Quando o upload for concluído, você verá uma mensagem parecida com esta:

Upload project frameworks/native/ to remote branch main:
 branch codelab ( 1 commit, Wed Aug 7 09:32:33 2019 -0700):
        ff46b36d android codelab change
to https://android-review.googlesource.com/ (y/N)? y
remote: Processing changes: refs: 1, new: 1, done
remote:
remote: SUCCESS
remote:
remote:   https://android-review.googlesource.com/c/platform/frameworks/native/+/1098432 android codelab change [NEW]
remote:
To https://android-review.googlesource.com/platform/frameworks/native
* [new branch]          codelab -> refs/for/main

Ver a mudança no Gerrit

Para ver sua mudança no Gerrit, navegue até a saída do link no terminal. O link tem esta aparência:

https://android-review.googlesource.com/c/platform/frameworks/native/+/1098432

Reverter a mudança

Normalmente, após o teste, a revisão e a aprovação, você envia e integra a mudança do Gerrit no repositório. Em vez disso, para os fins deste codelab, reverta seu trabalho:

No Gerrit, clique em Abandon.
Abandone a ramificação temporária associada no diretório do projeto frameworks/native ou nos subdiretórios dele:
```
repo abandon codelab .
```
Reverta as mudanças feitas no arquivo de teste. Como você não executou repo start, git commit e repo upload na mudança de teste, é possível redefinir o arquivo em si. Supondo que você esteja no aosp/platform_testing directory, use o comando abaixo para redefinir o arquivo:
```
git reset HEAD tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java
git checkout .
```

Isso conclui o codelab para desenvolvimento da plataforma Android.

Ajuda

Se você encontrar erros neste codelab, informe-os no link do Issue Tracker na parte de baixo de qualquer uma das páginas. Envie perguntas para o grupo android-building (em inglês).

Digite ps -A | grep crosvm para ver se crosvm já está em execução. Se crossvm estiver em execução, digite stop_cvd || true ou kill crosvm com o processo PID.