Fai da te: compila la ROM Android dal codice sorgente

Android è il sistema operativo mobile più utilizzato al mondo. E la parte migliore, è completamente open-source, il che in parole povere significa che il codice sorgente, il programma vero e proprio, è disponibile apertamente per consentire a tutti di scaricare, personalizzare e creare le proprie ROM.

Ci sono molte distribuzioni Android personalizzate disponibili là fuori, le più popolari sono CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, ecc.

Per la guida di oggi, compileremo CyanogenMod 10.2, la ROM aftermarket Android più popolare. La procedura è uguale al 99% per tutte le ROM personalizzate disponibili, quindi questa guida può essere utilizzata come riferimento per compilare anche altre ROM.

Pre-requisiti

1. Un telefono Android con Kernel e Device Source prontamente disponibili, già rootato e con un ripristino personalizzato installato.
2. Distribuzione Linux a 64 bit (preferiamo Ubuntu).
3. Almeno 100GB liberi sul tuo Hard Disk.
4. Conoscenza operativa dei comandi del terminale Linux.
5. Connessione Internet ragionevolmente veloce.

Punto da notare: Il sistema operativo Linux a 64 bit è un must e deve essere un'installazione nativa, non una macchina virtuale.

Configura la tua macchina da costruzione

1. Installa il sistema operativo Linux di tua scelta: Versione a 64 bit, secondo le istruzioni ufficiali. (La guida presumerà che stiamo eseguendo Ubuntu 13.04). Mantieni una partizione di almeno 100 GB con una partizione di scambio da 16 GB.

2. Installa il seguente elenco di pacchetti: Apri l'app Terminale e digita

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

premi invio e ti verrà chiesto di inserire la password.

Lista del pacchetto

[html]
git core
gnupg
flettere
bisonte
python
raro
originale-awk
guardare con aria sciocca
p7zip-pieno
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
strumenti di squashfs
costruire-essenziale
chiusura
arricciare
libncurses5-dev
zlib1g-dev
pngcrash
strumento di pianificazione
libc6-dev
x11proto-core-dev
libx11-dev
libg11-mesa-dev
mingw32
tofrodi
pitone-markdownmark
libxml2-utils
g++-multilib
lib32z1-dev
ia32-libs
lib32ncurses5-dev
lib32readline-gplv2-dev
gcc-multilib
g++-multilib
xsltproc
[/ Html]

3. Installa Java JDK 1.6 per Linux a 64 bit: Il nome del file dovrebbe essere jdk-6u##-linux-x64.bin, ## sono i numeri di versione. Sposta il pacchetto scaricato nella tua home directory. Apri l'app Terminale ed esegui il seguente set di comandi:

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

Ora, dobbiamo aggiungere JDK Path a .bashrc

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

Aggiungi queste righe alla fine del file di testo

[html]
# Percorso Java
esporta JAVA_HOME=/opt/java/64/jdk1.6.0_##
esporta PERCORSO=$PERCORSO:$JAVA_HOME/bin
[/ Html]

4. Installa Android SDK: Apri l'app Terminale

[html]
cd ~
mkdir android && cd android
mkdir sdk
[/ Html]

Scarica Android SDK da http://developer.android.com/sdk/index.html. Estrai il contenuto del pacchetto in ~/android/sdk Dobbiamo aggiungere il percorso dell'SDK di Android in .bashrc

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

Aggiungi queste righe alla fine del file di testo:

[html]
# Percorso SDK Android
esporta PERCORSO=$PERCORSO:~/android/sdk
esporta PATH=$PATH:~/android/sdk/platform-tools
esporta PATH=$PATH:~/android/sdk/tools
[/ Html]

Ora installa Android SDK Tools digitando

[html]
androide
[/ Html]

5. Configura il tuo account github e il repository remoto: Puoi saltare questo passaggio se CyanogenMod supporta ufficialmente il tuo telefono. Vai su github.com e crea un account per te stesso. Per questa guida, considero il tuo nome utente come "utente".

Visita "github.com/CyanogenMod/android", premi Fork. Il manifest remoto verrà forkato e sarà disponibile nel tuo repository personale.

Ora vai su "github.com/user/android". Apri il file default.xml, premi Modifica. Trova questa riga:

[html]

[/ Html]

E sostituiscilo con

[html]

[/ Html]

Sto considerando l'origine del kernel del tuo dispositivo, l'origine del dispositivo e le librerie del fornitore per Android 4.3 per essere a

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

Suppongo che il ramo si chiami 'jb4.3'. Puoi trovare il nome esatto nel repository effettivo. Quindi, alla fine del file, aggiungi queste righe, modificandole in base al codice sorgente del tuo dispositivo.

[html]




[/ Html]

Conferma le tue modifiche. Il tuo manifest remoto è pronto per essere distribuito.

6. Installa il comando repository: Apri Terminale e digita

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

Dobbiamo aggiungere il percorso Repo a .bashrc

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

Aggiungi questa riga alla fine del file di testo

[html]
export PERCORSO=$PERCORSO:~/bin
[/ Html]

7. Recupera il codice sorgente della ROM: Apri Terminale e digita

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

Se hai bisogno del passaggio 5, digita

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

Se il tuo dispositivo supporta ufficialmente CyanogenMod 10.2, digita

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

Ora corri

[html]
sincronizzazione repository –j16
[/ Html]

Vai a prenderti un caffè o un pasto, ci vorrà molto tempo. Il codice sorgente ha una dimensione ben superiore a 10 GB, quindi ci vorrà un po' di tempo.

8. Imposta le cose specifiche del dispositivo: Se il tuo dispositivo supporta ufficialmente CyanogenMod 10.2, apri Terminale e digita

[html]
cd~/androide/cm
. build/envsetup.sh && colazione
[/ Html]

Ci vorrà del tempo, la sorgente del dispositivo è di circa 3 GB. Quindi, devi avere CM10.2 ufficiale installato sul tuo telefono, collegarlo al tuo PC in modalità USB Debugging ed eseguire i seguenti comandi:

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

Se il tuo dispositivo non supporta ufficialmente CyanogenMod 10.2, non hai nulla da fare in questo passaggio, le fonti ti stanno già aspettando.

9. Scarica materiale predefinito e configura Toolchain: Apri Terminale e digita

[html]
cd ~/android/cm/fornitore/cm
sh ./get-prebuilt
[/ Html]

Ora, dobbiamo aggiungere il PATH di Toolchain a ./bashrc

[html]
cd~/androide/cm
sudo gedit ~ / .bashrc
[/ Html]

Aggiungi queste righe alla fine del file di testo

[html]
# Toolchain Android
esporta ARCH=braccio
esporta CCOMPILE=$CROSS_COMPILE
esporta CROSS_COMPILE=arm-eabi-
esporta PATH=$PATH:~/android/cm/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin
[/ Html]

10. Costruisci la tua ROM: Quindi, tutto è a posto e pronto. È il momento di costruire la ROM. Apri Terminale e digita

[html]
cd~/androide/cm
. build/envsetup.sh
brunch
[/ Html]

È ora di andare a fare un pisolino. Ci vorranno un trilione di anni per costruire la ROM su un computer medio. Beh, era un'esagerazione, ma sul mio PC di casa (Core i5 di seconda generazione con 2 GB di RAM), ci vogliono più di 8 ore per costruire da zero. Si spera che non ci siano errori e che la build venga completata correttamente. Riceverai il pacchetto di output in

[html]
~/android/cm/fuori/target/prodotto/ /cm-10.2-qualcosa-NON UFFICIALE- .cerniera lampo
[/ Html]

È ora di installare la ROM appena compilata sul telefono. Scarica il pacchetto Google Apps da "www.goo.im/gapps" per la versione Android appropriata. Metti entrambi i pacchetti nel telefono e esegui il flashing in modalità di ripristino. Voilà, la tua ROM compilata ora sta eseguendo il tuo dispositivo.

Bene, quindi hai imparato a compilare una ROM. E ora?

Aggiorna la tua ROM di origine

Per recuperare nuovi aggiornamenti del codice sorgente per il codice sorgente scaricato localmente, apri Terminale e digita

[html]
cd~/androide/cm
sincronizzazione repository –j16
[/ Html]

Per costruire la tua ROM, dopo aver aggiornato il codice sorgente, apri il terminale e digita

[html]
cd~/androide/cm
fai installclean
trova ./out/ -name 'build.prop' | xargs rm
trova ./out/ -name 'cm_ -target_files-eng.*.zip' | xargs rm
. build/envsetup.sh
brunch
[/ Html]

Dal momento che non stai ricostruendo da zero, ma ricostruendo così com'è, ci vorrà molto meno tempo, solo circa 15-30 minuti nella maggior parte dei casi. Dovresti sincronizzare la tua fonte locale ogni settimana circa, per mantenere la tua fonte locale fresca.

Pulisci la tua directory di lavoro

Per pulire completamente la tua directory di lavoro (leggi: riporta la cartella di origine alle condizioni di magazzino), apri Terminale e digita i seguenti comandi.

[html]
cd~/androide/cm
fai installclean
fare clobber
[/ Html]

Tieni presente che dopo aver eseguito questi comandi, tutti i tuoi dati di output verranno rimossi, quindi la build successiva richiederà ancora 3-4 ore, poiché tutto viene ricostruito da zero. Se la tua partizione del disco rigido è piccola, diciamo circa 100 GB, dovresti pulire la tua directory di lavoro circa una volta ogni 4 build, altrimenti esaurirai lo spazio sul disco rigido.

Velocizza la tua build con CCACHE

La creazione di una ROM richiede molto tempo. Ma il tempo può essere ridotto di circa il 30-45% utilizzando CCACHE. CCACHE sta per compiler cache, memorizza nella cache l'output della compilazione dalle build precedenti, in modo che possa essere riutilizzato nelle build successive.

Nota che CCACHE ha bisogno di molto spazio sul tuo disco rigido per memorizzare nella cache il contenuto, quindi è consigliato se e solo se la partizione del tuo disco rigido è da qualche parte nelle vicinanze di 200 GB o più. Per configurare CCACHE, apri Terminale e digita:

[html]
cd~/androide/cm
esporta USE_CCACHE=1
esporta CACHE_DIR=~/.ccache
precompilati/misc/linux-x86/ccache/ccache –M 50G
[/ Html]

È possibile modificare l'allocazione della dimensione massima in CCACHE da 50 GB a ciò che si desidera, ma per ottenere buoni risultati è necessario utilizzare un minimo di circa 30 GB.

Recupera commit da altre ROM

Puoi selezionare le funzionalità dal codice sorgente di altre ROM. Diciamo, ad esempio, che voglio scegliere la caratteristica A, con l'ID commit "12345" dal repository "github.com/user/reporepo".

Vai al pacchetto nel codice sorgente locale ed esegui questi in Terminale.

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

Collegamenti al codice sorgente delle famose distribuzioni di ROM personalizzate Android

CyanogenMod – https://github.com/CyanogenMod
Slim ROM – https://github.com/SlimRoms
Androide paranoico – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
Liquido Liscio – https://github.com/liquidsmooth
ROM Xylon -
Gelatina ghiacciata – https://github.com/IceColdJelly

Quindi, ecco qua ragazzi, una guida semplice e diretta per compilare praticamente qualsiasi ROM basata su Android AOSP in 10 semplici passaggi. Mentre la mia guida si concentra su CyanogenMod, puoi compilare praticamente tutte le ROM AOSP disponibili, semplicemente modificando i collegamenti al repository. Oppure puoi semplicemente scegliere funzionalità, impegnarle, modificare cose e creare la tua ROM personalizzata, magari condividere anche la tua ROM online?