Requisitos

Antes de fazer o download e criar a origem do Android, verifique se seu sistema

atende aos requisitos a seguir. Consulte Como estabelecer um ambiente de criação
para ver as instruções de instalação por sistema operacional.
Requisitos de hardware
Sua estação de trabalho de desenvolvimento precisa atender ou exceder estes
requisitos de hardware:
 Um ambiente de 64 bits é necessário para o Android 2.3.x (Gingerbread) e
versões posteriores, incluindo o branch master. É possível compilar versões
antigas em sistemas de 32 bits.
 Pelo menos 250 GB de espaço livre em disco para verificar o código e mais
150 GB para criá-lo. Se você realizar várias compilações, precisará de ainda
mais espaço.
Observação: se você estiver verificando um espelho, precisará de mais
espaço, porque os espelhos completos do Android Open Source Project
(AOSP) contêm todos os repositórios Git que já foram usados.
 Caso execute o Linux em uma máquina virtual, você precisará de pelo
menos 16 GB de RAM/swap.
Requisitos de software
O branch master do Android Open Source Project (AOSP) é tradicionalmente
desenvolvido e testado em versões Long Term Support (LTS) do Ubuntu, mas outras
distribuições podem ser usadas. Veja abaixo a lista das versões recomendadas.
Sua estação de trabalho precisa ter os softwares listados abaixo. Consulte Como
estabelecer um ambiente de criação para ver outros pacotes obrigatórios e os
comandos para instalá-los.
Estes requisitos se aplicam ao branch master do AOSP. Para as versões 8.0 (Oreo
ou O) a 5.0 (Lollipop ou L) do Android, considere o uso do Dockerfile incluído para
facilitar a instalação de todos os pacotes necessários. Para usar o método manual,
consulte Como oferecer compatibilidade para versões anteriores.
SO
Se você estiver desenvolvendo no branch master do AOSP, use um destes sistemas
operacionais: Ubuntu 14.04 (Trusty) ou as versões mais recentes do Mac OS e do
Xcode com as ferramentas de linha de comando instaladas.
JDK
O branch master do Android no AOSP vem com uma versão pré-criada do
OpenJDK, portanto, nenhuma outra instalação é necessária.
As versões mais antigas do Android exigem uma instalação separada do JDK. No
Ubuntu, use o OpenJDK. Consulte Como oferecer compatibilidade para versões
anteriores para as versões exatas e instruções.
Pacotes principais
O branch master do AOSP vem com uma versão pré-criada do Make, portanto,
nenhuma outra instalação é necessária.
 GNU Make 3.81 a 3.82 para versões mais antigas
 Python 2.7
 Git 1.7 ou versão posterior
Binários de dispositivos
Faça o download de visualizações, imagens de fábrica, drivers, atualizações over the air (OTA) e
outros blobs abaixo. Para ver mais detalhes, consulte Como adquirir binários reservados.
 Binários de visualização (blobs). Para desenvolvimento de branch master do
AOSP.
 Imagens de fábrica. Para dispositivos compatíveis que executam branches
de versão marcados do AOSP.
 Arquivos de suporte de hardware binários. Para dispositivos que executam
branches de versão marcados do AOSP.
Cadeia de ferramentas de criação
O Android 8.0 e as versões posteriores são compatíveis apenas com o Clang/LLVM
para criação da plataforma Android. Participe do grupo android-llvm para fazer
perguntas e receber ajuda. Informe problemas de NDK/compilador no NDK GitHub.
Para o Native Development Kit (NDK) e os kernels legados, também é possível usar
o GCC 4.9 incluído no branch master do AOSP (em prebuilts/).
Apoiando Versões Antigas
Esses requisitos se aplicam a versões mais antigas do Android. Para a ramificação
master do Android Open Source Project (AOSP), consulte os Requisitos padrão e
Estabelecendo um Ambiente de Construção . Para as versões do Android 8.0 (Oreo
ou O) até 5.0 (Lollipop ou L), considere o uso do Dockerfile incluído para facilitar a
instalação de todos os pacotes necessários.
Sistemas operacionais
O Android é normalmente construído com um sistema operacional GNU / Linux ou
Mac OS. Também é possível construir o Android em uma máquina virtual em
sistemas não suportados, como o Windows.
Recomendamos construir no GNU / Linux em vez de outro sistema operacional. O
sistema de compilação do Android normalmente usa o ART, em execução na
máquina de compilação, para pré-compilar arquivos dex do sistema. Como o ART é
capaz de ser executado apenas no Linux, o sistema de compilação ignora essa
etapa de pré-compilação em sistemas operacionais não Linux, resultando em uma
compilação do Android com desempenho reduzido.
GNU/Linux
 Android 6.0(Marshmallow) - AOSP master: Ubuntu 14.04(Trusty)
 Android 2.3.x(Gingerbread) - Android 5.x(Lollipop): Ubuntu 12.04 (Precise)
 Android 1.5 (Cupcake) - Android 2.2.x (Froyo): Ubuntu 10.04 (Lucid)
Mac OS (Intel/x86)
 Android 6.0(Marshmallow) - AOSP master: Mac OS v10.10(Yosemite) ou
posterior com Xcode 4.5.2 e as ferramentas de linha de comando
 Android 5.x (Lollipop): Mac OS v10.8 (Mountain Lion) com Xcode 4.5.2 e
ferramentas de linha de comando
  Android 4.1.x-4.3.x(Jelly Bean) - Android 4.4.x(KitKat): Mac OS v10.6 (SnowLeopard)
ou Mac OS X v10.7 (Lion) e Xcode 4.2 (Ferramentas de Desenvolvimento da Apple)
 Android 1.5(Cupcake) - Android 4.0.x(Ice Cream Sandwich): Mac OS v10.5(Leopard)
ou Mac OS X v10.6(Snow Leopard) no Mac OS X v10.5 SDK
Make
Para evitar erros de compilação, o Android 4.0.x (Ice Cream Sandwich) e anterior
deve reverter do make 3.82.
Xcode e outros pacotes
Para versões mais antigas do Mac OS (10.8 ou anteriores), você deve instalar o
Xcode no site do desenvolvedor da Apple . Se você ainda não está registrado como
desenvolvedor da Apple, você deve criar um ID da Apple para fazer o download.
Se estiver usando o Mac OS X v10.4, instale também o bison:
POSIXLY_CORRECT = 1 sudo port install bisonte
Para MacPorts, problema:
POSIXLY_CORRECT = 1 sudo port instalar gmake libsdl git gnupg
Para Homebrew, questão:
brew instalar gmake libsdl git gnupg2
Revertendo de fazer 3.82
No Android 4.0.x (Ice Cream Sandwich) e anteriormente, existe um bug no gmake
3.82 que impede a construção do Android. Você pode instalar a versão 3.81 usando
MacPorts com estas etapas:
1. Edite /opt/local/etc/macports/[Link] adicione uma linha que diz:
[Link]
acima da linha rsync. Em seguida, crie este diretório:
mkdir /Users/Shared/dports
2. No novo diretório dports, execute:
svn co --revision 50980
[Link] \
devel/gmake/
3. Crie um índice de porta para seu novo repositório local:
portindex / Users / Shared / dports
4. Instale a versão antiga do gmake com:
sudo port install gmake @3.81
JDK
 Android 7.0 (Nougat) - Android 8.0 (Oreo): Ubuntu - OpenJDK 8, Mac OS
- jdk 8u45 ou mais recente
 Android 5.x (Lollipop) - Android 6.0 (Marshmallow): Ubuntu - OpenJDK 7,
Mac OS- [Link]
 Android 2.3.x (Gingerbread) - Android 4.4.x (KitKat): Ubuntu - Java JDK 6,
Mac OS - Java JDK 6
  Android 1.5 (Cupcake) - Android 2.2.x (Froyo): Ubuntu - Java JDK 5
JDK para Linux
O master branch do Android no Android Open Source Project (AOSP) vem com
versões pré-construídas do OpenJDK abaixo, prebuilts/jdk/ portanto, nenhuma
instalação adicional é necessária.
Versões mais antigas do Android exigem uma instalação separada do JDK. No
Ubuntu, use o OpenJDK. Veja os Requisitos do JDK para versões precisas e as
seções abaixo para instruções.
Para o Ubuntu> = 15.04
Run the following:
sudo apt-get update
sudo apt-get install openjdk-8-jdk
Para o Ubuntu LTS 14.04
Não há pacotes OpenJDK 8 suportados disponíveis para o Ubuntu 14.04. Os
pacotes do OpenJDK 8 do Ubuntu 15.04 foram usados com sucesso com o Ubuntu
14.04. Versões de pacote mais recentes (por exemplo, aquelas para 15.10, 16.04)
foram encontradas para não funcionar em 14.04 usando as instruções abaixo.
1. Faça o download dos pacotes .deb para arquitetura de 64 bits em old-
[Link]:
openjdk-8-jre-headless_8u45-b14-1_amd64.deb com SHA256 0f5aba8db3
9088283b51e00054813063173a4d8809f70033976f8 3e214ab56c0
openjdk-8-jre_8u45-b14-1_amd64.deb comSHA256 9ef76c4562d39432b69baf6c
18f199707c5c56a5b4566847df908b 7d74e15849
openjdk-8-jdk_8u45-b14-1_amd64.deb com SHA256 6e47215cf6205aa829e6
a0a64985075bd29d1f428a4006a80c9db 371c2fc3c4c
2. Opcionalmente, confirme as somas de verificação dos arquivos baixados em
relação à string SHA256 listada com cada pacote acima. Por exemplo, com a
ferramenta sha256sum:
sha256sum {[Link] file}
3. Instale os pacotes:
sudo apt-get update
Execute o dpkg para cada um dos arquivos .deb que você baixou. Pode produzir
erros devido a falta de dependências:
sudo dpkg -i {[Link] file}
Para corrigir dependências ausentes:
sudo apt-get -f install
Atualize a versão padrão do Java - opcional
Opcionalmente, para as versões do Ubuntu acima, atualize a versão padrão do Java
executando:
sudo update-alternatives --config java
 sudo update-alternatives --config javac
Como estabelecer um ambiente de criação
Esta seção descreve como configurar seu ambiente de trabalho local para criar os
arquivos de origem do Android. É preciso usar o Linux ou o Mac OS. No momento,
não é possível realizar a criação no Windows.
Para ter uma visão geral de todo o processo de revisão e atualização de código,
consulte O ciclo de um patch.
Observação: todos os comandos neste site são precedidos por um sinal cifrão ($)
para diferenciá-los da saída ou das entradas nos arquivos. Você pode usar o recurso
Clique para copiar no canto superior direito de cada caixa de comando para copiar
todas as linhas sem os cifrões ou clicar três vezes em cada linha para copiá-la
individualmente sem o cifrão.
Como escolher um branch
Alguns requisitos para o ambiente de criação são determinados pela versão do
código-fonte que você planeja compilar. Para ver uma lista completa dos branches
disponíveis, consulte Números de versão. Você também pode optar por fazer o
download e criar o código-fonte mais recente (chamado master), caso em que
simplesmente omitirá a especificação do branch ao inicializar o repositório.
Depois de selecionar uma ramificação, siga as instruções apropriadas abaixo para
configurar seu ambiente de criação.
Como configurar um ambiente de criação do Linux
Estas instruções aplicam-se a todas as filiais, incluindo o mestre.
A criação do Android é testada internamente com frequência em versões recentes
do Ubuntu LTS (14.04) e testes do Debian. A maioria das outras distribuições
precisa ter as ferramentas de criação necessárias disponíveis.
Para Gingerbread (2.3.x) e versões mais recentes, incluindo a ramificação principal,
é necessário um ambiente de 64 bits. Versões mais antigas podem ser compiladas
em sistemas de 32 bits.
Observação: consulte Requisitos para ver a lista completa dos requisitos de
hardware e software e siga as instruções detalhadas para o Ubuntu e Mac OS
abaixo.
Como instalar os pacotes necessários (Ubuntu 14.04)
Você precisará de uma versão de 64 bits do Ubuntu. O Ubuntu 14.04 é
recomendado.
sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl
zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev x11proto-
core-dev libx11-dev lib32z-dev libgl1-mesa-dev libxml2-utils xsltproc unzip
Observação: para usar as ferramentas SELinux para análise de políticas, instale
também o pacote python-networkx.
Observação: se você estiver usando LDAP e quiser executar testes de host ART,
instale também o pacote libnss-sss:i386.
Como instalar os pacotes necessários (Ubuntu 12.04)
Você pode usar o Ubuntu 12.04 para criar versões mais antigas do Android. A
versão 12.04 não é compatível com as versões recentes ou master.
sudo apt-get install git gnupg flex bison gperf build-essential zip curl libc6-dev
libncurses5-dev:i386 x11proto-core-dev libx11-dev:i386 libreadline6-dev:i386
libgl1-mesa-glx:i386 libgl1-mesa-dev g++-multilib mingw32 tofrodos
python-markdown libxml2-utils xsltproc zlib1g-dev:i386
sudo ln -s /usr/lib/i386-linux-gnu/mesa/[Link].1 \
/usr/lib/i386-linux-gnu/[Link]
Como instalar os pacotes necessários (Ubuntu 10.04 a 11.10)
A criação no Ubuntu 10.04 a 11.10 não é mais compatível, mas pode ser útil para
criar versões mais antigas do AOSP.
sudo apt-get install git gnupg flex bison gperf build-essential zip curl zlib1g-dev
libc6-dev lib32ncurses5-dev ia32-libs x11proto-core-dev libx11-dev lib32readline5-
dev lib32z-dev libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown
libxml2-utils xsltproc
No Ubuntu 10.10:
sudo ln -s /usr/lib32/mesa/[Link].1 /usr/lib32/mesa/[Link]
No Ubuntu 11.10:
sudo apt-get install libx11-dev:i386
Configurando o acesso USB
Instale um conjunto padrão de regras udev mantido pela comunidade para todos os
dispositivos Android seguindo as instruções para Configurar um dispositivo para
desenvolvimento.
Como usar um diretório de saída separado
Por padrão, a saída de cada construção é armazenada no sub-diretório out/ da
árvore de origem correspondente.
Em alguns computadores com vários dispositivos de armazenamento, as versões
são mais rápidas ao armazenar os arquivos de origem e a saída em volumes
separados. Para ter melhor desempenho, a saída pode ser armazenada em um
sistema de arquivos otimizado para velocidade em vez de resistência contra falhas,
já que todos os arquivos podem ser gerados novamente caso o sistema de arquivos
seja corrompido.
Para configurar isso, exporte a variável OUT_DIR_COMMON_BASE para apontar
para o local onde os diretórios de saída serão armazenados.
export OUT_DIR_COMMON_BASE=<path-to-your-out-directory>
O diretório de saída para cada árvore de origem separada será nomeado após o
diretório que contém a árvore de origem. Por exemplo, se você tiver árvores de
origem como /source/master1 e /source/master2 e OUT_DIR_COMMON_BASE está
definido como /output, os diretórios de saída serão /output/master1 e
/output/master2.
Nesse caso, é importante não ter várias árvores de origem armazenadas em
diretórios com o mesmo nome, pois elas acabam compartilhando um diretório de
saída, com resultados imprevisíveis. Isso só é suportado no Jelly Bean (4.1) e mais
recente, incluindo o branch master.
Como configurar um ambiente de criação do Mac OS
Em uma instalação padrão, o Mac OS é executado em um sistema de arquivos que
é indiferente a maiúsculas, mas que as preserva. Esse tipo de sistema de arquivos
não é compatível com o git e fará com que alguns comandos git (como git status) se
comportem de maneira anormal. Por isso, recomendamos que você sempre trabalhe
com os arquivos de origem do AOSP em um sistema de arquivos com distinção
entre maiúsculas e minúsculas. Isso pode ser feito com bastante facilidade,
utilizando uma imagem de disco, conforme discutido abaixo.
Depois que o sistema de arquivos adequado estiver disponível, é muito simples criar
o branch master em um ambiente Mac OS moderno. Branches anteriores exigem
algumas outras ferramentas e SDKs.
Como criar uma imagem de disco com diferenciação entre maiúsculas e
minúsculas
Você pode criar um sistema de arquivos com distinção entre maiúsculas e
minúsculas no seu ambiente Mac OS atual usando uma imagem de disco. Para criar
a imagem, abra o Utilitário de Disco e selecione Nova imagem. O tamanho de 25 GB
é o mínimo para concluir a criação. Quanto maior o número, melhor será a
compatibilidade futura. Usar imagens esparsas economiza espaço, permitindo
futuras ampliações de acordo com a necessidade. Selecione Distinção de
maiúsculas, Journaling como o formato de volume.
Você também pode criá-lo a partir de um shell com o seguinte comando:
hdiutil create -type SPARSE -fs 'Case-sensitive Journaled HFS+' -size 40g
~/[Link]
Isso criará um arquivo .dmg (ou possivelmente um arquivo .[Link]) que,
uma vez montado, atua como uma unidade com a formatação necessária para o
desenvolvimento do Android.
Se você precisar de um volume maior posteriormente, também poderá
redimensionar a imagem esparsa com o seguinte comando:
hdiutil resize -size <new-size-you-want>g ~/[Link]
Para uma imagem de disco chamada [Link] armazenada no seu diretório
inicial, adicione as funções auxiliares ao seu ~/.bash_profile:
 Para montar a imagem ao executar o mountAndroid:
# mount the android file image
mountAndroid() { hdiutil attach ~/[Link] -mountpoint \
/Volumes/android; }
Observação: se o seu sistema criou um arquivo .[Link], substitua
~/[Link] por ~/[Link].
 Para desconectá-la ao executar umountAndroid:
 # desmontar a imagem do arquivo android
 umountAndroid() { hdiutil detach /Volumes/android; }
Depois de ativar o volume android, você fará todo o seu trabalho lá. Será possível
ejetá-lo (desconectá-lo) exatamente como você faria com um disco externo.
Como instalar o Xcode e outros pacotes
1. Instale as ferramentas de linha de comando do Xcode com:
xcode-select --install
Para versões mais antigas do Mac OS (10.8 ou anteriores), é necessário instalar o
Xcode no site da Apple para desenvolvedores. Se você ainda não está registrado
como desenvolvedor da Apple, crie um ID Apple para fazer o download.
2. Instale o MacPorts ou Homebrew para gerenciar pacotes.
3. Verifique se o diretório associado está no caminho correto dentro do arquivo
~/.bash_profile:
a. MacPorts - /opt/local/bin precisa aparecer antes de /usr/bin:
export PATH=/opt/local/bin:$PATH
b. Homebrew - /usr/local/bin:
export PATH=/usr/local/bin:$PATH
c. Para MacPorts, emita:
POSIXLY_CORRECT=1 sudo port install git gnupg
d. Para Homebrew, emita:
brew install git gnupg2
Como definir um limite de descritor de arquivo
No Mac OS, o limite padrão do número de descritores de arquivos simultâneos
abertos é muito baixo, e um processo de criação altamente paralelo pode exceder
esse limite. Para aumentar o limite, adicione as seguintes linhas ao seu
~/.bash_profile:
# set the number of open files to be 1024
ulimit -S -n 1024
Fazer o download da origem
Seu ambiente de criação está pronto. Prossiga para Como fazer o download da
origem.
Como fazer o download da origem
A árvore de origem do Android está localizada em um repositório Git hospedado pelo
Google. O repositório Git contém metadados da origem do Android, incluindo
aqueles relacionados a alterações da origem e à data em que foram feitas. Este
documento descreve como fazer o download da árvore de origem para uma linha de
código Android específica.
Para iniciar com uma imagem de fábrica para um dispositivo específico, consulte
Como selecionar uma versão de dispositivo.
Como instalar o Repo
O Repo é uma ferramenta que facilita o trabalho com o Git no contexto do Android.
Para ver mais informações sobre o Repo, consulte a Referência de comando do
Repo.
Para instalar o Repo:
1. Verifique se você tem um diretório bin/ no seu diretório inicial e se ele está
incluído no seu caminho:
mkdir ~/bin
PATH=~/bin:$PATH
2. Faça o download da ferramenta Repo e verifique se ela é executável:
curl [Link] > ~/bin/repo
chmod a+x ~/bin/repo
Para a versão 1.23, o checksum SHA-256 para repo é
e147f0392686c40cfd7d5e6f332c6ee74c4eab4d24e2694b3b0a0c037bf51dc5.
Para a versão 1.25, o checksum SHA-256 para repo é
d06f33115aea44e583c8669375b35aad397176a411de3461897444d247b6c220.
Como inicializar um cliente do Repo
Depois de instalar o Repo, configure seu cliente para acessar o repositório de
origem do Android:
1. Crie um diretório vazio para guardar seus arquivos de trabalho. Se você
estiver usando o MacOS, isso deve estar em um sistema de arquivos que faz
distinção entre maiúsculas e minúsculas. Dê-lhe qualquer nome que você
goste:
mkdir WORKING_DIRECTORY
cd WORKING_DIRECTORY
2. Configure o git com seu nome e endereço de e-mail reais. Para usar a
ferramenta de revisão de código Gerrit, você precisará de um endereço de
e-mail conectado a uma Conta do Google registrada. Esse precisa ser um
endereço ativo onde você possa receber mensagens. O nome que você
fornecer aqui aparecerá em atribuições para os envios de código.
git config --global [Link] "Your Name"
git config --global [Link] "you@[Link]"
3. Execute repo init para trazer a versão mais recente do Repo com todas as
correções de bugs mais recentes. É preciso especificar um URL para o
manifesto, que especifica onde os vários repositórios incluídos na origem do
Android serão colocados no seu diretório de trabalho.
repo init -u [Link]
Para verificar uma ramificação diferente de "master", especifique-a com -b.
Para obter uma lista de ramificações, consulte Tags e construções de código-
fonte.
repo init -u [Link] \
-b android-4.0.1_r1
Uma inicialização bem-sucedida terminará com uma mensagem informando que o
Repo foi inicializado no seu diretório de trabalho. Seu diretório cliente agora conterá
um diretório .repo onde arquivos como o manifesto serão mantidos.
Como fazer o download da árvore de origem do Android
Para receber a árvore de origem do Android para o diretório de trabalho dos
repositórios, conforme especificado no manifesto padrão, execute
repo sync
Os arquivos de origem do Android se encontrarão no seu diretório de trabalho sob
os nomes dos projetos. A operação de sincronização inicial levará uma hora ou mais
para ser concluída. Para ver mais informações sobre repo sync e outros comandos
repo, consulte Desenvolvimento.
Como usar a autenticação
Por padrão, o acesso ao código-fonte do Android é anônimo. Para proteger os
servidores contra o uso excessivo, cada endereço IP é associado a uma cota.
Ao compartilhar um endereço IP com outros usuários (por exemplo, ao acessar os
repositórios de origem através de um firewall NAT), as cotas podem ser acionadas
mesmo para padrões de uso regulares (por exemplo, se muitos usuários
sincronizarem novos clientes do mesmo endereço IP em um curto período).
Nesse caso, é possível usar o acesso autenticado, que utiliza uma cota separada
para cada usuário, independentemente do endereço IP.
O primeiro passo é criar uma senha com o gerador de senhas e seguir as instruções
na página do gerador de senhas.
O segundo passo é forçar o uso de acesso autenticado utilizando o seguinte URI de
manifesto: [Link] Observe como o
prefixo do diretório /a/ aciona a autenticação obrigatória. Você pode converter um
cliente existente para usar a autenticação obrigatória com o seguinte comando:
repo init -u [Link]
Como solucionar problemas de rede
Ao fazer o download por um proxy (o que é comum em alguns ambientes
corporativos), pode ser necessário especificar explicitamente o proxy que será
usado pelo Repo:
export HTTP_PROXY=[Link]
er>:<proxy_port>
export HTTPS_PROXY=[Link]
ver>:<proxy_port>
Mais raramente, os clientes Linux enfrentam problemas de conectividade, ficando
travados no meio de downloads (normalmente durante o "Recebimento de objetos").
Foi relatado que ajustar as configurações da pilha TCP/IP e usar comandos não
paralelos pode melhorar a situação. É preciso acessar a raiz para modificar a
configuração do TCP:
sudo sysctl -w net.ipv4.tcp_window_scaling=0
repo sync -j1
Como usar um espelho local
Ao usar vários clientes, especialmente em situações em que a largura de banda é
escassa, é melhor criar um espelho local de todo o conteúdo do servidor e
sincronizar os clientes desse espelho (que não requer acesso à rede). O download
de um espelho completo é menor que o de dois clientes, contendo mais
informações.
Estas instruções supõem que o espelho é criado em /usr/local/aosp/mirror. O
primeiro passo é criar e sincronizar o espelho em si. Observe o sinalizador --mirror,
que pode ser especificado apenas ao criar um novo cliente:
mkdir -p /usr/local/aosp/mirror
cd /usr/local/aosp/mirror
repo init -u [Link] --mirror
repo sync
Depois que o espelho é sincronizado, novos clientes podem ser criados com base
nele. Observe que é importante especificar um caminho absoluto:
mkdir -p /usr/local/aosp/master
cd /usr/local/aosp/master
repo init -u /usr/local/aosp/mirror/platform/[Link]
repo sync
Por fim, para sincronizar um cliente com o servidor, o espelho precisa ser
sincronizado com o servidor e, em seguida, o cliente com o espelho:
cd /usr/local/aosp/mirror
repo sync
cd /usr/local/aosp/master
repo sync
É possível armazenar o espelho em um servidor LAN e acessá-lo via NFS, SSH ou
Git. Também é possível armazená-lo em uma unidade removível e passar essa
unidade para os usuários ou as máquinas.
Como verificar as tags do Git
Carregue a seguinte chave pública para seu banco de dados de chaves do GnuPG.
A chave é usada para assinar tags anotadas que representam versões.
gpg --import
Copie e cole a chave abaixo e, em seguida, insira EOF (Ctrl-D) para finalizar a
entrada e processar as chaves.

-----BEGIN PGP PUBLIC KEY BLOCK-----

Version: GnuPG v1.4.2.2 (GNU/Linux)

mQGiBEnnWD4RBACt9/h4v9xnnGDou13y3dvOx6/
t43LPPIxeJ8eX9WB+8LLuROSVlFhpHawsVAcFlmi7f7jdSRF+OvtZL9ShPKdLfwBJM
NkU66/
TZmPewS4m782ndtw78tR1cXb197Ob8kOfQB3A9yk2XZ4ei4ZC3i6wVdqHLRxABdn
cwu5hOF9KXwCgkxMDu4PVgChaAJzTYJ1EG+UYBIUEAJmfearb0qRAN7dEoff0Fe
XsEaUA6U90sEoVks0ZwNj96SA8BL+a1OoEUUfpMhiHyLuQSftxisJxTh+2QclzDviDy
aTrkANjdYY7p2cq/
HMdOY7LJlHaqtXmZxXjjtw5Uc2QG8UY8aziU3IE9nTjSwCXeJnuyvoizl9/
I1S5jU5SA/9WwIps4SC84ielIXiGWEqq6i6/
sk4I9q1YemZF2XVVKnmI1F4iCMtNKsR4MGSa1gA8s4iQbsKNWPgp7M3a51JCVCu
6l/8zTpA+uUGapw4tWCp4o0dpIvDPBEa9b/aF/
ygcR8mh5hgUfpF9IpXdknOsbKCvM9lSSfRciETykZc4wrRCVGhlIEFuZHJvaWQgT3
BlbiBTb3VyY2UgUHJvamVjdCA8aW5pdGlhbC1jb250cmlidXRpb25AYW5kcm9pZC5j
b20+iGAEExECACAFAknnWD4CGwMGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAA
KCRDorT+BmrEOeNr+AJ42Xy6tEW7r3KzrJxnRX8mij9z8tgCdFfQYiHpYngkI2t09Ed
+9Bm4gmEO5Ag0ESedYRBAIAKVW1JcMBWvV/0Bo9WiByJ9WJ5swMN36/
vAlQN4mWRhfzDOk/Rosdb0csAO/
l8Kz0gKQPOfObtyYjvI8JMC3rmi+LIvSUT9806UphisyEmmHv6U8gUb/
xHLIanXGxwhYzjgeuAXVCsv+EvoPIHbY4L/
KvP5x+oCJIDbkC2b1TvVk9PryzmE4BPIQL/NtgR1oLWm/
uWR9zRUFtBnE411aMAN3qnAHBBMZzKMXLWBGWE0znfRrnczI5p49i2YZJAjyX1
P2WzmScK49CV82dzLo71MnrF6fj+Udtb5+OgTg7Cow+8PRaTkJEW5Y2JIZpnRUq0
CYxAmHYX79EMKHDSThf/8AAwUIAJPWsB/MpK+KMs/
s3r6nJrnYLTfdZhtmQXimpoDMJg1zxmL8UfNUKiQZ6esoAWtDgpqt7Y7sKZ8laHRAR
onte394hidZzM5nb6hQvpPjt2OlPRsyqVxw4c/KsjADtAuKW9/
d8phbN8bTyOJo856qg4oOEzKG9eeF7oaZTYBy33BTL0408sEBxiMior6b8LrZrAhkq
DjAvUXRwm/
fFKgpsOysxC6xi553CxBUCH2omNV6Ka1LNMwzSp9ILz8jEGqmUtkBszwoG1S8fXg
E0Lq3cdDM/GJ4QXP/
p6LiwNF99faDMTV3+2SAOGvytOX6KjKVzKOSsfJQhN0DlsIw8hqJc0WISQQYEQIA
CQUCSedYRAIbDAAKCRDorT+BmrEOeCUOAJ9qmR0lEXzeoxcdoafxqf6gZlJZlACg
kWF7wi2YLW3Oa+jv2QSTlrx4KLM==Wi5D

-----END PGP PUBLIC KEY BLOCK-----

Depois de importar as chaves, você pode verificar qualquer tag com
git tag -v TAG_NAME
Preparo para a criação
As instruções a seguir para criar a árvore de origem do Android se aplicam a todos
os branches, incluindo o master. A sequência básica dos comandos de criação é a
seguinte.
Adquirir binários reservados
O AOSP não pode ser usado apenas a partir do código-fonte puro e requer que
outras bibliotecas reservadas relacionadas a hardware sejam executadas, como
para aceleração de gráficos de hardware. Consulte as seções abaixo para ver os
links de download e Binários do dispositivo para ver outros recursos.
Alguns dispositivos têm esses binários reservados na partição /vendor deles.
Fazer o download de binários reservados
Você pode fazer o download de binários oficiais para os dispositivos compatíveis
que executam branches de versões AOSP marcadas dos drivers do Google. Esses
binários acrescentam acesso a outras funcionalidades de hardware com código-
fonte não aberto. Para criar o branch master do AOSP, use a Visualização de
binários. Ao criar o branch master de um dispositivo, use os binários para a versão
numerada mais recente ou com a data mais recente.
Extrair binários reservados
Cada conjunto de binários é fornecido como um script de autoextração em um
arquivo compactado. Descompacte cada arquivo, execute o script de autoextração
incluído na raiz da árvore de origem e confirme que você concorda com os termos
do contrato de licença. Os binários e seus makefiles correspondentes serão
instalados na hierarquia vendor/ da árvore de origem.
Limpeza
Para garantir que os binários recém-instalados sejam devidamente considerados
após serem extraídos, exclua a saída existente de qualquer versão anterior usando:
make clobber
Configurar o ambiente
Inicialize o ambiente com o script [Link]. Observe que a substituição de source
por . (um único ponto) economiza alguns caracteres, e o formato curto é mais
comumente usado na documentação.
source build/[Link]
ou
.build/[Link]
Escolher um destino
Escolha qual destino criar com o lunch. A configuração exata pode ser passada
como um argumento. Por exemplo, o comando a seguir se refere a uma versão
completa para o emulador, com toda a depuração ativada:
lunch aosp_arm-eng
Se executado sem argumentos, o lunch solicitará que você escolha um destino no
menu. Consulte Como selecionar uma versão de dispositivo para ver as
configurações de versão de todos os dispositivos existentes.
Todos os destinos de criação assumem o formato BUILD-BUILDTYPE, onde BUILD
é um codinome que se refere à combinação específica de recursos. O BUILDTYPE
é um dos seguintes:
Tipo da versão Uso
user acesso limitado; adequado para produção
userdebug como user, mas com acesso root e capacidade de depuração; o
mais indicado para depuração
eng configuração de desenvolvimento com outras ferramentas de
depuração
A versão userdebug precisa se comportar da mesma forma que a user, com a
capacidade de ativar depuração adicional, que normalmente viola o modelo de
segurança da plataforma. Isso faz com que userdebug seja uma boa versão para
testes de usuários com maiores recursos de diagnóstico. Ao desenvolver com a
versão userdebug, siga as diretrizes de userdebug.
A versão eng prioriza a produtividade de engenharia para engenheiros que
trabalham na plataforma. Ela desativa várias otimizações usadas para fornecer uma
boa experiência ao usuário. Fora isso, a versão eng se comporta de maneira
semelhante às versões user e userdebug, para que os desenvolvedores de
dispositivos possam ver como o código se comporta nesses ambientes.
Para ver mais informações sobre como criar e executar em hardwares reais,
consulte Como executar versões.
Criar o código
Esta seção é meramente um resumo para garantir que a configuração esteja
concluída. Consulte Como executar versões para ver instruções detalhadas sobre a
criação do Android.
Crie tudo com make. O GNU make pode gerenciar tarefas paralelas com um
argumento -jN, e é comum usar várias tarefas N, que são entre uma e duas vezes o
número de threads de hardware no computador que está sendo usado para a
criação. Por exemplo, em um computador dual-E5520 (2 CPUs, 4 núcleos por CPU,
2 threads por núcleo), as criações mais rápidas são feitas com comandos entre
make -j16 e make -j32.
make -j4
Executar
Você pode executar sua versão em um emulador ou armazená-la em flash em um
dispositivo. Observe que você já selecionou o destino da versão com lunch, e é
improvável que ela seja executada em um destino diferente daquele para o que foi
criada.
Observação: lembre-se de adquirir os binários reservados ou sua versão não
será inicializada com sucesso no hardware de destino. Se adquirir os blobs
binários, você precisará descompactá-los, make clobber e recriar.
Atualização flash com fastboot
Para realizar a atualização flash de um dispositivo, você precisará usar o fastboot,
que precisa ser incluído no seu caminho após uma criação bem-sucedida. Consulte
Como realizar uma atualização flash em um dispositivo para ver mais instruções.
Emular um dispositivo Android
O emulador é adicionado ao seu caminho automaticamente pelo processo de
criação. Para executá-lo, digite:
emulator
Como solucionar erros de criação comuns
Versão incorreta do Java
Se você está tentando criar uma versão do Android inconsistente com sua versão do
Java, make será cancelado com uma mensagem como
************************************************************
You are attempting to build with the incorrect version
of java.

Your version is: WRONG_VERSION.

The correct version is: RIGHT_VERSION.

Please follow the machine setup instructions at

[Link]
************************************************************
Estas são as prováveis causas e soluções:
 Falha ao instalar o JDK correto conforme especificado nos Requisitos do
JDK. Verifique se você seguiu as etapas apresentadas em Configurar o ambiente e
escolher um destino.
 Outro JDK instalado anteriormente aparece no seu caminho. Inclua o JDK
correto no início do seu caminho ou remova o JDK problemático.
Versão 3 do Python
O repo foi projetado com uma funcionalidade específica do Python 2.x e,
infelizmente, é incompatível com o Python 3. Para usar o repo, instale o Python 2.x:
apt-get install python
Sistema de arquivos indiferente a maiúsculas
Se você estiver criando em um sistema de arquivos HFS no Mac OS, poderá
encontrar um erro como
*********************************************************************
You are building on a case-insensitive filesystem.
Please move your source tree to a case-sensitive filesystem.
*********************************************************************
Siga as instruções apresentadas em Como criar uma imagem de disco com
diferenciação de maiúsculas e minúsculas.
Sem permissão para USB
Na maioria dos sistemas Linux, por padrão, os usuários não privilegiados não podem
acessar as portas USB. Se você encontrar um erro de permissão negada, siga as
instruções em Como configurar o acesso por USB.
Se o adb já estiver em execução e não for possível se conectar ao dispositivo depois
definir as regras, ele poderá ser eliminado com adb kill-server. Isso fará com que o
adb seja reiniciado com a nova configuração.
Limpe seu diretório de trabalho
Para limpar completamente seu diretório de trabalho (leia: retorne sua pasta de
origem para a condição de estoque), abra o Terminal e digite os seguintes
comandos.
cd ~ /android/cm
make installclean
make clobber
Lembre-se de que, depois de executar esses comandos, todos os seus dados de
saída serão removidos, portanto, a próxima versão levará de 3 a 4 horas novamente,
já que tudo é reconstruido a partir do zero. Se a sua partição do disco rígido for
pequena, digamos, cerca de 100 GB, você deve limpar seu diretório de trabalho uma
vez a cada 4 compilações, ou então, você ficará sem espaço no disco rígido.