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

Codelab para desenvolvedores Android

Você pode ajudar a desenvolver o sistema operacional mais instalado da história. Sim, você está prestes a embarcar em uma aventura para se tornar um engenheiro da Plataforma Android.

Embora o caminho seja desafiador, a equipe do Android se esforça para simplificar sua jornada a cada novo lançamento. A equipe também faz melhorias todos os dias com trabalho direto no Android Open Source Project (AOSP).

Então, sente-se, abra um terminal e vamos fazer história.

Objetivos

Este codelab tem dois objetivos:

Mostrar um pouco do que é o fluxo de trabalho do desenvolvedor para os engenheiros do Android que trabalham na plataforma (o sistema operacional).
Incentivar você a enviar feedback sobre as ferramentas, a documentação e o fluxo de trabalho do desenvolvedor Android.

Pré-requisitos

Os requisitos para este codelab derivam daqueles para o desenvolvimento da plataforma geral (AOSP). Para realizar este codelab, é necessário configurar:

Uma estação de trabalho física do Linux que atenda a todos os requisitos públicos.
O Repo e o Git necessários para editar a base de código Android.

Ambiente

Normalmente, os usuários criam e desenvolvem diretamente na estação de trabalho. Como é possível usar vários terminais, e muitos dos comandos usados são relacionados ao terminal, será necessário executá-los novamente em cada sessão. Especificamente, isso inclui os comandos source build/envsetup.sh e lunch.

Configurar a estação de trabalho

Instale os pacotes necessários na estação de trabalho.
Enquanto ainda estiver em um terminal, instale o Repo e receba as credenciais para todos os repositórios Git.

Inicializar e sincronizar o código

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 -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 -j8
```

As sincronizações iniciais podem levar uma hora ou mais.

Cada checkout de repo é representado por um arquivo de manifesto. É possível fazer mais de um checkout do Repo por vez, contanto que eles existam em diretórios diferentes. No entanto, cada checkout e build usa aproximadamente 300 GB, e esse número continua crescendo. Portanto, use dois checkouts do Repo como limite ou aumente o armazenamento do sistema com um drive secundário.

DICA: para aumentar o espaço disponível, exclua um diretório de ramificação e comece novamente pela criação do diretório, desta maneira: rm -rf aosp2.

Criar o código

Para criar o código do Android, você precisa selecionar um tipo de dispositivo de destino e usar o comando lunch para criação. Um destino é uma permutação do dispositivo, como um modelo ou formato específico.

O destino do dispositivo aosp_cf_x86_64_phone-userdebug possibilita criar o dispositivo virtual Android Cuttlefish para testes sem um dispositivo físico.

Para criar e atualizar um dispositivo físico, escolha outro destino e siga as instruções para atualizar dispositivos.

Para configurar o ambiente para a criação de dispositivos Android, execute o comando a seguir na raiz do checkout do código-fonte:
```
source build/envsetup.sh
```
Transmita o destino do build para o comando lunch, desta maneira:
```
lunch aosp_cf_x86_64_phone-trunk_staging-userdebug
```
Crie o código de qualquer lugar do checkout com:
```
m
```

A conclusão do primeiro build leva horas. Os builds futuros levam muito menos tempo.

Iniciar o Cuttlefish

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

Se você nunca instalou o Cuttlefish, precisa instalar as dependências necessárias desse emulador. Em uma janela do terminal, execute os seguintes comandos 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. Você verá um stream de vídeo do dispositivo Android que acabou de criar.

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> .
```
Edite SurfaceFlinger.cpp para incluir as atualizações da lista de mudanças no local mostrado abaixo:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```

Encontre esta linha:

void SurfaceFlinger::updateColorMatrixLocked() {

Adicione estas duas linhas no início de updateColorMatrixLocked():

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
adb sync
adb reboot

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

Exemplo de uma mudança de cor bem-sucedida

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

Testar o código

Esta parte do codelab usa um exemplo de teste que está na árvore de origem e que apresenta falha. O Atest é empregado para executar o teste do código localmente.

Para usar o teste, siga estas instruções:

Execute:
```
atest DevCodelabTest
```

O teste vai falhar. 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)

Depois, veja este exemplo:

platform_testing/tests/example/devcodelab

Para poder editar o arquivo, veja o nome do teste em android.test.example.devcodelab.DevCodelabTest e substitua o . por / para ver este resultado:
```
src/android/test/example/devcodelab/DevCodelabTest.java
```

Depois edite

platform_testing/tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java

para substituir

Assert.assertTrue(false)

por

Assert.assertTrue(true)

Execute o teste novamente para verificar se 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.

Consulte Ferramentas de controle de origem para ter visões gerais do Git e do Repo com links para a documentação completa sobre como trabalhar com o código-fonte do Android. Consulte o repositório AOSP para ver a lista completa de projetos Git e os projetos individuais (caminhos) das ramificações associadas a cada projeto.

Para a análise de código dos seus projetos no Git, você usará o sistema de revisão de código baseado na Web, Gerrit.

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 confirmação, 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

Acesse o link exibido no terminal, que se parecerá com este:

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

Isso conclui o codelab básico para desenvolvimento da plataforma Android. Consulte Como enviar patches para conferir as próximas etapas. Para mais detalhes sobre o desenvolvimento do Android, consulte o restante deste site.

Reverter a mudança

Normalmente, após o teste, a revisão e a aprovação, você envia e integra a mudança no Gerrit no repositório.

Em vez disso, para os fins deste codelab, reverta a lista de mudanças clicando em Abandon no Gerrit.

Em seguida, abandone a ramificação temporária associada no diretório do projeto frameworks/native ou nos subdiretórios dele:

repo abandon codelab .

Não esqueça de reverter as mudanças feitas no arquivo de teste. Como você não fez a mudança repo start, git commit e repo upload, é possível redefinir o próprio arquivo. Supondo que você esteja no aosp/platform_testing directory, use o comando a seguir para redefinir o arquivo:

git reset HEAD tests/example/devcodelab/src/android/test/example/devcodelab/DevCodelabTest.java
git checkout .

Você terminou o codelab. Bom trabalho!

Receber 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.