Fai da te: Compilare Android ROM dal codice sorgente

Gennaio 18, 2022

Android è il sistema operativo mobile più utilizzato al mondo. E la parte migliore, è completamente open-source, che in termini profani, significa che il codice sorgente, il programma attuale è disponibile apertamente per tutti di scaricare, personalizzare e costruire le proprie ROM.

Ci sono un sacco di distribuzioni Android personalizzate disponibili là fuori, con quelli popolari che sono CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, ecc.

Per la guida di oggi, compileremo CyanogenMod 10.2, il più popolare Android aftermarket ROM. La procedura è 99% la stessa per tutte le ROM personalizzate là fuori, quindi questa guida può essere utilizzata come riferimento per compilare altre ROM troppo.

Pre-requisiti

Un telefono Android con Kernel e sorgente del dispositivo prontamente disponibili, già radicato e con un ripristino personalizzato installato.
Distribuzione Linux a 64 bit (preferiamo Ubuntu).
Almeno 100GB gratis sul tuo disco rigido.
Conoscenza dei comandi del terminale Linux.
Connessione Internet ragionevolmente veloce.

Nota: il sistema operativo Linux a 64 bit è un must e deve essere un’installazione nativa, non una macchina virtuale.

Configura la tua macchina di compilazione

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

2. Installa il seguente elenco di pacchetti: Apri l’app Terminal e digita

sudo apt-get install <package-name>

premi invio e ti verrà richiesta la tua password.

Elenco dei Pacchetti

git-core
gnupg
flex
bison
python
rar
original-awk
gawk
p7zip-full
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
squashfs-tools
build-essential
zip
curl
libncurses5-dev
zlib1g-dev
pngcrush
schedtool
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

3. Install Java JDK 1.6 for Linux 64-bit: File name should be jdk-6u##-linux-x64.bin, ## are version numbers. Move the downloaded package to your home directory. Apri l’app Terminal ed esegui il seguente set di comandi:

se hai bisogno di aiuto, ti preghiamo di inviarci una richiesta di aiuto.in questo caso, il sistema di gestione dei dati non è più in grado di gestire i dati personali.contenitore
./ jdk-6u##-linux-x64.bin
exit

Ora, dobbiamo aggiungere il percorso JDK a .bashrc

sudo gedit ~/.bashrc

Aggiungi queste righe alla fine del file di testo

# Percorso Java
esporta JAVA_HOME= / opt / java / 64 / jdk1. 6. 0_##
esporta PERCORSO=PATH PERCORSO:JAV JAVA_HOME / bin

4. Installare Android SDK: Terminale aperto App

cd ~
mkdir android && cd Android
mkdir sdk

Scaricare Android SDK da http://developer.android.com/sdk/index.html. Estrai il contenuto del pacchetto in ~ / android / sdk A cui dobbiamo aggiungere il percorso SDK di Android .bashrc

sudo gedit ~/.bashrc

Aggiungi queste righe alla fine del file di testo:

# Android SDK Path
export PATH = PATH PATH: ~ /android / sdk
export PATH = PATH PATH:~ / android / sdk / platform-tools
export PATH=PATH PATH:~ / android / sdk / strumenti

Ora, installare Android SDK Strumenti digitando

Android

5. Imposta il tuo account github e repo remoto: puoi saltare questo passaggio se CyanogenMod supporta ufficialmente il tuo telefono. Vai a github.com, e faccia un conto per Lei. Per questa guida, sto considerando il tuo nome utente come “utente”.

Visita ‘github.com/CyanogenMod/android’, premere Forcella. Il manifest remoto sarà biforcuto e disponibile nel repository personale.

Ora, vai a ‘github.com/user/android’. Aprire il file predefinito.xml, premere Modifica. Trova questa linea:

E sostituire con

sto valutando il tuo dispositivo sorgente del kernel, dispositivo di origine del fornitore e libs per Android 4.3 a

github.com/user2/kernel_source
github.com/user2/device_source
github.com/user2/device-common_source
github.com/user2/vendor

sto assumendo il ramo per essere chiamato ” 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.

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

6. Installa il comando Repo: apri il terminale e digita

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

Dobbiamo aggiungere il percorso Repo a .bashrc

sudo gedit ~/.bashrc

Aggiungi questa riga alla fine del file di testo

esporta PERCORSO = PATH PERCORSO: ~ / bin

7. Recupera il codice sorgente della ROM: Aprire il Terminale e digitare

mkdir ~/android/cm
cd ~/android/cm

Se avete bisogno di Passaggio 5, quindi digitare

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

Se il dispositivo supporta la CyanogenMod 10.2 ufficialmente, quindi digitare

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

Ora esegui

repo sync –j16

Andare a prendere un caffè o un pasto, non è andando a prendere un lungo periodo di tempo. Il codice sorgente è ben più di 10 GB di dimensione, quindi ci vorrà un po ‘ di tempo.

8. Impostare la roba specifica del dispositivo: Se il dispositivo supporta CyanogenMod 10.2 ufficialmente, quindi aprire Terminale e digitare

cd ~/android/cm
. build/envsetup.sh & & colazione < device_codename>

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

radice adb
cd ~/android/cm/device/<your_company>/<your_device>/
./extract-files.sh

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

9. Scarica roba precompilata e imposta Toolchain: Apri terminale e digita

cd ~ / android / cm / vendor / cm
sh ./ get-prebuilts

Ora, dobbiamo aggiungere il PERCORSO della Toolchain ./ bashrc

cd ~ / android / cm
sudo gedit ~/.bashrc

Aggiungi queste righe alla fine del file di testo

# Android Toolchain
esporta ARCH=braccio
esporta CCOMPILE=$CROSS_COMPILE
esporta CROSS_COMPILE=arm-eabi-
export PATH=$PATH:~/android/cm/predefiniti/linux-x86/toolchain/braccio-eabi-4.4.3/bin

10. Costruisci la tua ROM: Quindi, tutto è a posto e pronto. È tempo di costruire la ROM. Aprire il terminale e digitare

cd ~/android/cm
. build/envsetup.sh
brunch <device_codename>

E ‘ ora di andare a fare un pisolino. Ci vorranno un miliardo di anni per costruire la ROM su un computer medio. Beh, era un’esagerazione, ma sul mio PC di casa (Core i5 2nd gen con 8GB di RAM), ci vogliono più di 3 ore per costruire da zero. Speriamo che non ci saranno errori e la build andrà a finire bene. Si otterrà il pacchetto di uscita in

~/android/cm/out/target/product/<your_device>/cm-10.2-something-UNOFFICIAL-<your_device>.zip

È il momento di installare la ROM appena compilata sul telefono. Scarica il pacchetto Google Apps da ” www.Goo.im / gapps ” per la versione Android appropriata. Mettere entrambi i pacchetti nel telefono, e flash in modalità di ripristino. Voilà, la tua ROM compilata ora esegue il tuo dispositivo.

Bene, così hai imparato come compilare una ROM. E ora che si fa?

Aggiorna il Tuo di Origine ROM

Per recuperare i nuovi aggiornamenti al codice sorgente per il tuo locale scaricato il codice sorgente, aprire il Terminale e digitare

cd ~/android/cm
repo sync –j16

Per costruire la vostra ROM, dopo l’aggiornamento del codice sorgente, aprire il terminale, e tipo

cd ~/android/cm
fare installclean
trova ./ out / – nome ‘build.prop ‘ / xargs rm
trovare ./ out / – name ‘ cm_ < your_device> – target_files-ita.*.zip ‘ / xargs rm
. build/envsetup.sh
brunch <your_device>

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 o giù di lì, per mantenere fresca la tua fonte locale.

Pulisci la tua directory di lavoro

Per pulire completamente la tua directory di lavoro (leggi: restituire la cartella di origine alla condizione stock), aprire Terminale e digitare i seguenti comandi.

cd ~/android/cm
make installclean
make clobber

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

Velocizza la tua build di CCACHE

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

Si noti che CCACHE ha bisogno di molto spazio sul disco rigido per la memorizzazione nella cache del contenuto, quindi è consigliato se e solo se la partizione del disco rigido è da qualche parte nelle vicinanze di 200 GB o superiore. Per impostare CCACHE, aprire Terminale e digitare:

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

È possibile modificare l’allocazione delle dimensioni massime in CCACHE da 50 GB a quello che si desidera, ma un minimo di circa 30 GB dovrebbe essere utilizzato per ottenere buoni risultati.

Fetch Commit da altre ROM

È possibile cherry-pick caratteristiche da altri ROM codice sorgente. Ad esempio, voglio scegliere la funzione A, con l’ID di commit “12345” dal repository “github.com/user/reporepo”.

Si passa al pacchetto nel codice sorgente locale ed esegue questi nel Terminale.

cd ~/<path_to_reporepo_packages>
git fetch https://github.com/user/reporepo
git cherry-pick 12345

Il Codice sorgente Link del Famoso Android Custom ROM Distribuzioni

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
LiquidSmooth – https://github.com/liquidsmooth
Xylon ROM –
Ghiaccio Freddo Jelly– https://github.com/IceColdJelly

Così, ci si va ragazzi, una semplice guida per la compilazione praticamente qualsiasi Android AOSP ROM basata su in 10 semplici passi. Mentre la mia guida si concentra su CyanogenMod, puoi compilare praticamente tutte le ROM AOSP là fuori, semplicemente modificando i collegamenti del repository. Oppure, puoi semplicemente scegliere le funzionalità, impegnarle, modificare le cose e creare la tua ROM personalizzata, magari condividere anche la tua ROM online?

NCPEA Professor

Blog, Lifestyle and News