Esta página foi traduzida pela API Cloud Translation.

Codelab para desenvolvedores Android

Você pode ajudar a desenvolver o sistema operacional mais instalado na história da Terra. Sim, você está aqui para embarcar na jornada de 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 lançamento. E a equipe faz melhorias todos os dias por meio do trabalho direto no Android Open Source Project (AOSP).

Então relaxe, ligue um terminal e vamos fazer história.

Metas

A missão deste codelab é dupla:

Para lhe dar uma pequena amostra de como é o fluxo de trabalho do desenvolvedor para engenheiros Android que trabalham na plataforma (o sistema operacional).
Incentive você a fornecer feedback sobre as ferramentas, a documentação e o fluxo de trabalho do desenvolvedor do Android.

Pré-requisitos

A lista de requisitos deste codelab deriva daquelas para desenvolvimento de plataforma geral ( AOSP ). Para fazer este codelab, configure o seguinte:

Estação de trabalho física Linux atendendo a todos os requisitos públicos .
Repo e a configuração do Git necessária para editar a base de código do Android.

Ambiente

Normalmente, os usuários constroem e desenvolvem diretamente na estação de trabalho. Como você pode estar trabalhando em vários terminais e muitos dos comandos usados são específicos do terminal, você precisará executá-los novamente em cada sessão do terminal. Especificamente, eles incluem os comandos source build/envsetup.sh e lunch .

Configurar estação de trabalho

Instale os pacotes necessários em sua estação de trabalho.
Ainda em um terminal, instale o Repo e obtenha credenciais para todos os repositórios Git.

Inicialize e sincronize o código

Navegue até seu diretório inicial:
```
cd ~
```
Crie um subdiretório de trabalho local dentro dele:
```
mkdir aosp
```
Navegue até o diretório:
```
cd aosp
```
Inicialize a ramificação principal 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 do repositório é representado por um arquivo de manifesto . É permitido ter mais de um checkout de repositório por vez, desde que existam em diretórios distintos. Mas observe que cada checkout e build equivale a aproximadamente 300 GB de uso (e crescente), então limite-se a 2 checkouts de repositório ou aumente seu sistema com uma unidade secundária.

DICA: Para aumentar o espaço livre, exclua um diretório de ramificação e comece novamente a partir da criação do diretório, assim: rm -rf aosp2.

Construa o código

Para compilar o Android, você deve selecionar um tipo de dispositivo de destino para compilar com o comando lunch . Um destino é uma permutação de dispositivo, como um modelo ou formato específico.

O destino do dispositivo aosp_cf_x86_64_phone-userdebug permite que você crie o dispositivo Android virtual Cuttlefish para teste sem um dispositivo físico.

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

Configure seu ambiente para criar dispositivos Android executando o seguinte comando na raiz da verificação do código-fonte:
```
source build/envsetup.sh
```
Passe o alvo de construção para o comando Lunch, assim:
```
lunch aosp_cf_x86_64_phone-trunk_staging-userdebug
```
Crie o código em qualquer lugar do seu checkout com:
```
m
```

Espere que a primeira construção leve horas. As compilações subsequentes levam significativamente menos tempo.

Lançar Choco

Cuttlefish é o emulador Android usado para testar suas compilações.

Se você nunca instalou o Cuttlefish, você deve instalar as dependências necessárias do Cuttlefish. Em uma janela de terminal, execute os seguintes comandos para baixar, construir e instalar os pacotes host 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 módulos adicionais do kernel e aplica regras udev .

Lançar Choco:
```
launch_cvd --daemon</code>
```
Conecte-se ao dispositivo Cuttlefish navegando até https://localhost:8443 em seu navegador. Você é saudado com um stream de vídeo do dispositivo Android que acabou de construir.

Faça uma mudança

Atualize o código-fonte seguindo este exemplo changelist .

Na raiz do seu checkout (diretório aosp/ ), navegue até o projeto frameworks/native 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 alterações no seguinte local:
```
aosp/frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
```
Encontre esta linha:
```
postComposition();
```

Substitua essas duas linhas pelo seguinte:

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();

Construa o código:
```
m
```

Atualize a compilação no dispositivo:

adb root
adb remount
adb sync
adb reboot

Verifique se você vê uma mudança de cor no dispositivo selecionado, semelhante ao mostrado na Figura 1.

Example of a successful color change

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

Teste seu código

Esta parte do codelab utiliza um teste de exemplo que está na árvore de origem e está falhando. Isso emprega Atest para executar o teste localmente e testar o código.

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

Correr:
```
atest DevCodelabTest
```
O teste falhará. Para corrigir isso, encontre o código-fonte do teste com falha:
```
atest --info android.test.example.devcodelab.DevCodelabTest#testHelloWorld
```

Então olhe aqui

platform_testing/tests/example/devcodelab

Para fazer com que o arquivo seja editado, pegue o nome do teste em android.test.example.devcodelab.DevCodelabTest e substitua o . com / , para obter este resultado:
```
src/android/test/example/devcodelab/DevCodelabTest.java
```

Então edite

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

substituir

Assert.assertTrue(false)

com

Assert.assertTrue(true)

Execute o teste novamente para verificar se você corrigiu o problema:
```
atest DevCodelabTest
```

Envie seu código para revisão

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

Consulte Ferramentas de controle de origem para obter 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 obter a lista completa de projetos Git e os projetos individuais (caminhos) para ramificações associadas a cada projeto.

Para revisão de código de seus projetos no Git, você usará o sistema de revisão de código baseado na web Gerrit .

Supondo que você fez suas alterações no frameworks/native , execute estes comandos para carregá-los:
```
cd frameworks/native
repo start codelab .
git add .
git commit
```
Para sua mensagem de commit, digite o seguinte:
```
Android codelab change
Test: manual atest
```
Envie sua alteração:
```
repo upload
```

Se tiver sucesso, você verá uma mensagem semelhante a 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

Veja sua alteração no Gerrit

Acesse o link, impresso no terminal, que se assemelha a este:

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

Isso conclui o codelab inicial para desenvolvimento da plataforma Android. Consulte Envio de patches para as próximas etapas e, para obter detalhes completos sobre o desenvolvimento do Android, consulte o restante deste site.

Reverter sua alteração

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

Em vez disso, para os fins deste codelab, reverta sua lista de alterações clicando em Abandonar no Gerrit.

Em seguida, abandone o branch temporário associado no diretório frameworks/native project (ou seus subdiretórios):

repo abandon codelab .

Lembre-se também de reverter as alterações feitas no arquivo de teste. Como você não repo start , git commit e repo upload a alteração, você pode redefinir o próprio arquivo. Supondo que você esteja no aosp/platform_testing directory , use o seguinte para redefinir o arquivo:

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

Neste ponto, você terminou! Bom trabalho!

Obter ajuda

Se você encontrar erros durante este codelab, informe-os usando o link Issue Tracker na parte inferior de qualquer página. Envie perguntas para o grupo de construção de Android .