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.

Criar uma instância do Acloud

O Acloud é uma ferramenta de linha de comando no AOSP que ajuda os usuários a criar dispositivos virtuais Android, neste caso o Cuttlefish.

Se você estiver na mesma sessão do terminal usada para criar o código, siga as próximas etapas. Caso contrário, execute novamente o script envsetup.sh e o mesmo comando lunch usado no terminal em que criou o código. Depois disso:

Instale as dependências para a execução de um dispositivo virtual Cuttlefish localmente com:
```
acloud setup
```
Se solicitado, reinicie a estação de trabalho para que todas as mudanças entrem em vigor.

Crie uma instância local acloud com:

acloud create --local-image --local-instance

Selecione o dispositivo Cuttlefish.

Será exibida uma sessão VNC de boas-vindas com um dispositivo Android.

Você pode interagir com o dispositivo virtual na estação de trabalho usando o mouse e o teclado. Você também pode usar o comando logcat do Android Debug Bridge (adb) para acompanhar a atividade nos registros enquanto o dispositivo está em uso:

adb logcat

Fazer uma modificação

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:
```
postComposition();
```

Substitua essas duas linhas por estas:

postComposition();
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});
updateColorMatrixLocked();

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

Atualize o build no dispositivo:

adb root
adb remount
adb sync
adb reboot
acloud reconnect

Se for solicitado que você selecione um dispositivo, escolha aquele que mostre o menor tempo decorrido. Provavelmente, será o último da lista exibida. Para ver todas as instâncias de dispositivos virtuais, use os comandos acloud list e acloud list -v.

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 falhará. Para corrigi-lo, veja o código-fonte do teste com falha:

atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld

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 a mudança no Gerrit e a mescla 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 .

Lembre-se também 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!

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