Faça você mesmo: compilar Android ROM do código-fonte

O Android é o sistema operacional móvel mais usado no mundo. E a melhor parte, é totalmente de código aberto, o que em termos leigos, significa que o Código-fonte, o programa real, está disponível abertamente para que todos possam baixar, personalizar e construir suas próprias ROMs.

Existem muitas distribuições personalizadas do Android disponíveis, com as populares sendo CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, etc.

Para o guia de hoje, compilaremos o CyanogenMod 10.2, a ROM de reposição mais popular do Android. O procedimento é 99% o mesmo para todas as ROMs customizadas, então este guia pode ser usado como uma referência para compilar outras ROMs também.

Pré-requisitos

1. Um telefone Android com kernel e fonte de dispositivo prontamente disponíveis, já com acesso root e com uma recuperação personalizada instalada.
2. Distribuição Linux de 64 bits (preferimos Ubuntu).
3. Pelo menos 100 GB de espaço livre no disco rígido.
4. Conhecimento prático de Comandos de Terminal Linux.
5. Conexão de internet razoavelmente rápida.

Aponte para anotar: O sistema operacional Linux de 64 bits é obrigatório e deve ser uma instalação nativa, não uma máquina virtual.

Configure sua máquina de construção

1. Instale o sistema operacional Linux de sua escolha: Versão de 64 bits, de acordo com as instruções oficiais. (O guia presumirá que estamos executando o Ubuntu 13.04). Mantenha uma partição de pelo menos 100 GB com partição de troca de 16 GB.

2. Instale a seguinte lista de pacotes: Abra o aplicativo Terminal e digite

[html] sudo apt-get install [/ html]

pressione Enter e ele solicitará sua senha.

Lista de Pacotes

[html]
git-core
gnupg
flexionar
bisão
python
raro
original-awk
gawk
p7zip-full
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
ferramentas de squashfs
essencial para construir
zip
enrolar
libncurses5-dev
zlib1g-dev
pngcrush
agenda
libc6-dev
x11proto-core-dev
libx11-dev
libg11-mesa-dev
mingw32
tofrodos
python-markdown
libxml2-utils
g ++ - multilib
lib32z1-dev
ia32-libs
lib32ncurses5-dev
lib32readline-gplv2-dev
gcc-multilib
g ++ - multilib
xsltproc
[/ html]

3. Instale o Java JDK 1.6 para Linux de 64 bits: O nome do arquivo deve ser jdk-6u ## - linux-x64.bin, ## são números de versão. Mova o pacote baixado para seu diretório inicial. Abra o aplicativo Terminal e execute o seguinte conjunto de comandos:

[html]
sudo apt-get purge openjdk - \ * icedtea - \ * icedtea6 - \ *
sudo mkdir –p / opt / java / 64 /
sudo cp jdk-6u ## - linux-x64.bin / opt / java / 64
sul em -
cd / opt / java / 64
chmod a + x jdk-6u ## - linux-x64.bin
./jdk-6u##-linux-x64.bin
saída
[/ html]

Agora, devemos adicionar o caminho JDK a .bashrc

[html]
sudo gedit ~ / .bashrc
[/ html]

Adicione essas linhas no final do arquivo de texto

[html]
# Caminho Java
export JAVA_HOME = / opt / java / 64 / jdk1.6.0 _ ##
exportar PATH = $ PATH: $ JAVA_HOME / bin
[/ html]

4. Instale o Android SDK: Abra o Terminal App

[html]
cd ~
mkdir android && cd android
SDK mkdir
[/ html]

Baixe Android SDK de http://developer.android.com/sdk/index.html. Extraia o conteúdo do pacote para ~ / android / sdk. Devemos adicionar o caminho do Android SDK para .bashrc

[html]
sudo gedit ~ / .bashrc
[/ html]

Adicione estas linhas ao final do arquivo de texto:

[html]
# Caminho do Android SDK
exportar PATH = $ PATH: ~ / android / sdk
export PATH = $ PATH: ~ / android / sdk / platform-tools
exportar PATH = $ PATH: ~ / android / sdk / tools
[/ html]

Agora, instale o Android SDK Tools digitando

[html]
andróide
[/ html]

5. Configure sua conta github e repo remoto: Você pode pular esta etapa se CyanogenMod oferecer suporte oficial para o seu telefone. Vá para github.com e crie uma conta para você. Para este guia, estou considerando seu nome de usuário como 'usuário'.

Visite 'github.com/CyanogenMod/android', pressione Forquilha. O manifesto remoto será bifurcado e estará disponível em seu repositório pessoal.

Agora, vá para 'github.com/user/android'. Abra o arquivo default.xml e pressione Editar. Encontre esta linha:

[html]

[/ html]

E substitua isso por

[html]

[/ html]

Estou considerando a fonte do kernel do seu dispositivo, fonte do dispositivo e libs do fornecedor para Android 4.3 em

[html]
github.com/user2/kernel_source
github.com/user2/device_source
github.com/user2/device-common_source
github.com/user2/vendor
[/ html]

Estou assumindo que o ramo se chamará 'jb4.3'. Você pode encontrar o nome exato no repositório real. Depois, ao final do arquivo, adicione essas linhas, modificando-as de acordo com o código-fonte do seu dispositivo.

[html]




[/ html]

Comprometa suas mudanças. Seu manifesto remoto está pronto para ser implantado.

6. Instale o comando Repo: Abra o Terminal e digite

[html]
cd ~
mkdir ~ / bin
curl https://dl-ssl.google.com/dl/googlesource/git-repo/repo> ~ / bin / repo
chmod a + x ~ / bin / repo
[/ html]

Devemos adicionar o caminho do repositório para .bashrc

[html]
sudo gedit ~ / .bashrc
[/ html]

Adicione esta linha ao final do arquivo de texto

[html]
exportar PATH = $ PATH: ~ / bin
[/ html]

7. Obtenha o código-fonte da ROM: Abra o Terminal e digite

[html]
mkdir ~ / android / cm
cd ~ / android / cm
[/ html]

Se você precisar da Etapa 5, digite

[html]
repo init –u git: //github.com/user/android.git –b cm-10.2
[/ html]

Se o seu dispositivo for oficialmente compatível com CyanogenMod 10.2, digite

[html]
repo init –u git: //github.com/CyanogenMod/android.git –b cm-10.2
[/ html]

Agora corra

[html]
sincronização de repositório –j16
[/ html]

Vá tomar um café ou uma refeição, vai demorar muito. O código-fonte tem bem mais de 10 GB de tamanho, por isso levará algum tempo.

8. Configure as coisas específicas do dispositivo: Se o seu dispositivo for oficialmente compatível com CyanogenMod 10.2, abra o Terminal e digite

[html]
cd ~ / android / cm
. build / envsetup.sh e café da manhã
[/ html]

Levará algum tempo, a fonte do dispositivo tem cerca de 3 GB de tamanho. Então, você precisa ter o CM10.2 oficial instalado em seu telefone, conecte-o ao seu PC no modo de depuração USB e execute os seguintes comandos:

[html]
raiz adb
cd ~ / android / cm / dispositivo / / /
./extract-files.sh
[/ html]

Se o seu dispositivo não é compatível oficialmente com CyanogenMod 10.2, você não tem nada a fazer nesta etapa, as fontes já estão esperando por você.

9. Baixe o material pré-construído e configure o conjunto de ferramentas: Abra o Terminal e digite

[html]
cd ~ / android / cm / vendor / cm
sh ./get-prebuilds
[/ html]

Agora, devemos adicionar o PATH do conjunto de ferramentas a ./bashrc

[html]
cd ~ / android / cm
sudo gedit ~ / .bashrc
[/ html]

Adicione essas linhas ao final do arquivo de texto

[html]
# Cadeia de ferramentas do Android
exportar ARCH = arm
export CCOMPILE = $ CROSS_COMPILE
export CROSS_COMPILE = arm-eabi-
export PATH = $ PATH: ~ / android / cm / prebuilt / linux-x86 / toolchain / arm-eabi-4.4.3 / bin
[/ html]

10. Construa sua ROM: Então, está tudo certo e pronto. É hora de construir a ROM. Abra o Terminal e digite

[html]
cd ~ / android / cm
. build / envsetup.sh
Escovar
[/ html]

É hora de tirar uma soneca. Levará um zilhão de anos para construir a ROM em um computador comum. Bem, isso foi um exagero, mas no meu PC doméstico (Core i5 2ª geração com 8 GB de RAM), leva mais de 3 horas para construir do zero. Esperançosamente, não haverá erros e a compilação será concluída sem problemas. Você receberá o pacote de saída em

[html]
~ / android / cm / out / target / product / /cm-10.2-algo-UNOFFICIAL- .fecho eclair
[/ html]

É hora de instalar a ROM recém-compilada em seu telefone. Baixe o pacote do Google Apps em “www.goo.im/gapps” para a versão apropriada do Android. Coloque ambos os pacotes no seu telefone e atualize-os no modo de recuperação. Voila, sua própria ROM compilada agora está executando o seu dispositivo.

Bem, então você aprendeu a compilar uma ROM. Então, e agora?

Atualize sua ROM de origem

Para buscar novas atualizações de código-fonte para o código-fonte baixado localmente, abra o Terminal e digite

[html]
cd ~ / android / cm
sincronização de repositório –j16
[/ html]

Para construir sua ROM, após atualizar o código-fonte, abra o terminal e digite

[html]
cd ~ / android / cm
fazer instalação limpa
find ./out/ -name 'build.prop' | xargs rm
find ./out/ -name 'cm_ -target_files-eng. *. zip '| xargs rm
. build / envsetup.sh
Escovar
[/ html]

Como você não está reconstruindo do zero, mas reconstruindo como está, levará muito menos tempo, apenas cerca de 15-30 minutos na maioria dos casos. Você deve sincronizar sua fonte local a cada semana ou assim, para manter sua fonte local atualizada.

Limpe seu diretório de trabalho

Para limpar seu diretório de trabalho completamente (leia: retornar sua pasta de origem à condição de estoque), abra o Terminal e digite os seguintes comandos.

[html]
cd ~ / android / cm
fazer instalação limpa
fazer clobber
[/ html]

Lembre-se de que, depois de executar esses comandos, todos os dados de saída serão removidos, portanto, a próxima compilação levará de 3 a 4 horas novamente, já que tudo é refeito do zero. Se a partição do disco rígido for pequena, digamos cerca de 100 GB, você deve limpar o diretório de trabalho uma vez a cada 4 compilações, ou então ficará sem espaço no disco rígido.

Acelere sua construção por CCACHE

Construir uma ROM leva muito tempo. Mas o tempo pode ser reduzido em cerca de 30-45% usando CCACHE. CCACHE significa cache do compilador, ele armazena em cache a saída da compilação de suas compilações anteriores, para que possa ser reutilizada em compilações posteriores.

Observe que o CCACHE precisa de muito espaço no disco rígido para armazenar o conteúdo em cache, portanto, é recomendado se e somente se a partição do disco rígido estiver em torno de 200 GB ou superior. Para configurar o CCACHE, abra o Terminal e digite:

[html]
cd ~ / android / cm
export USE_CCACHE = 1
export CACHE_DIR = ~ / .ccache
prebuilts / misc / linux-x86 / ccache / ccache –M 50G
[/ html]

Você pode alterar a alocação de tamanho máximo para CCACHE de 50 GB para o que quiser, mas um mínimo de cerca de 30 GB deve ser usado para bons resultados.

Obter commits de outros ROMs

Você pode selecionar recursos do código-fonte de outras ROMs. Digamos, por exemplo, que eu queira escolher o Recurso A, com o ID de confirmação “12345” do repositório “github.com/user/reporepo”.

Você navega até o pacote em seu código-fonte local e os executa no Terminal.

[html]
cd ~ /
git buscar https://github.com/user/reporepo
git cherry-pick 12345
[/ html]

Links de código-fonte de distribuições famosas de ROM personalizadas para Android

CyanogenMod - https://github.com/CyanogenMod
SlimROM - https://github.com/SlimRoms
ParanoidAndroid - https://github.com/ParanoidAndroid
AOKP - https://github.com/AOKP
Líquido Suave - https://github.com/liquidsmooth
ROM Xylon -
Gelatina Gelada - https://github.com/IceColdJelly

Então, aí está, pessoal, um guia simples e direto para compilar virtualmente qualquer ROM baseada em AOSP do Android em 10 etapas simples. Embora meu guia se concentre no CyanogenMod, você pode compilar praticamente todas as ROMs AOSP existentes, apenas modificando os links do repositório. Ou você pode apenas escolher recursos, confirmá-los, modificar coisas e criar sua própria ROM personalizada, talvez compartilhar sua ROM online também?