[GUIDA] Come settare l'ambiente perfetto per buildare

Introduzione

Lo scopo di questa guida è, come dice il titolo del thread, quello di creare un ambiente di sviluppo perfetto per iniziare a scaricare, compilare e buildare le vostre ROM preferite. L'argomento non è quasi mai trattato nella sua interezza poiché le guide tendono a disperdere l'utente verso altre già compilate da altri (ma che spesso risultano imprecise) e spesso risultano non aggiornate.
Se siete ai primissimi passi con la compilazione android, questo thread è il posto giusto per iniziare.
Ovviamente non tratterò l'argomento device tree perché è troppo complesso e dispersivo ed è praticamente impossibile sapere il giusto device tree per ogni device esistente al mondo. Esiste comunque una rapida soluzione e consiste nello spulciare il github di una ROM già compilata per il vosto device, recarvi su vendor/[nome della rom] e guardare il file [nome della rom].dipendencies. Lì solitamente sono elencate le vostre dipendenze.

Come sapete Android monta una versione modificata del kernel Linux, per cui il processo di building delle relative ROM avverrà im ambiente Linux. Apprestiamoci ad imparare un po' di terminologia di base.

Terminologia di base

In qualsiasi guida, anche quelle che sono solito scrivere io, troverete un warning che vi dice che non vi sarà spiegata la terminologia di base di Linux, perché si suppone che per compiere un passo tanto grande ed impegnativo quale il processo di building, voi sappiate già queste cose.
Non è questo il caso comunque. Questa guida vi viene in soccorso proprio in questo. Vediamo alcuni termini prettamente Linuxiani.

Root

- ormai se siete dei modders, siete avvezzi con questo termine che può avere due significati: il root può essere di una cartella, ossia la cartella principale (in Linux indicata col simbolo /) o il particolare utente con i privilegi di amministratore (discorso che si traduce, nel mondo di Android, con la parola SuperSU o SuperUser).

Terminale

- lo strumento che fa la differenza. È una finestra dove immettere dei comandi in maniera testuale, in modo da interagire con la macchina. Su Ubuntu lo si apre con la combinazione di tasti ctrl+alt+t.

sudo

- comando, invocato dal terminale, per guadagnare l'accesso come root. Segue una richiesta di immissione password (che avrete scelto voi durante l'installazione di Linux).

DE, Desktop Enviroment

- tutto quello che vediamo nello schermo. Un sistema operativo può essere gestito testualmente, ma per venire incontro all'utente, si da un'interfaccia grafica a tutto. Il DE è appunto l'ambiente grafico di un sistema operativo, composto da barre laterali, dock etc etc.

Nautilus, Thunar, Dolphin

- sono tutti dei gestori file (o file manager, un po' come quelli android) coi quali ci interfacciamo graficamente ai file ed alle cartelle. Sono, rispettivamente, di Ubuntu (o comunque del DE Unity), del DE XFCE e del DE Dolphin.

gksu

- comando che apre come root un'applicazione.

repo

- può essere inteso come abbreviazione di repository, ma anche come un programma (scritto in python) che sincronizza i tuoi sorgenti con quelli online.

git

- un sistema per tenere online il codice sorgente.

Branch

- versione di un codice sorgente, solitamente correlato alla versione di android

cm-10.2, jb-mr2, kitkat-4.4

- sono un sistema di denominazione dei branch, rispettivamente di CyanogenMod, AOKP e Slim.

Gerrit

- un sistema di revisione del codice online che usa gli standard git.

Commit

- una patch, o comunque una modifica, non ancora implementata

Build

- può indicare il processo di buildare, ossia costruire, ma anche una milestone di una ROM (build 1.2, build 5.0 etc)

Cherry-pick

- integrare nel codice sorgente dei commit.

Clone

- l'azione di clonare dei repository sulla tua macchina.

Manifest

- un documento che contiene un elenco dei progetti (project) appartenenti alla ROM da scaricare.

Download ed installazione di una distro linux

Lavoriamo in ambiente Linux, per cui dobbiamo procurarci una distro. Nel pc che uso normalmente monto Linux Mint (basato su Ubuntu, ma con diverse modifiche del team), mentre il pc che uso per buildare, monta su Ubuntu classico (la 13.10).
Nella guida spiegherò l'installazione di Ubuntu classico, ma potete utilizzare anche altre distro (Debian, Fedora, Arch, Gentoo, ma se state usando queste, non avete neanche motivo di leggere la guida).

- scaricate la .iso di Ubuntu dal sito ufficiale Ubuntu-it.org, ma scaricate la versione a 64 bit! La maggior parte dei processi di build, compresi quelli del kernel, vi richiederanno questa architettura. E comunque, se vi aspettate di terminare la compilazione in un lasso di tempo decente (meno di 3 ore), vi conviene avere almeno una macchina dual core con architettura 64 bit.

- scaricate unetbootin dalla loro pagina di sourceforge unetbootin.sourceforge.net. Questo programma vi servirà a creare la pen drive avviabile. Volendo, potete masterizzare l'iso su DVD, per cui, se avete intenzione di utilizzare questo metodo, potete saltare questo punto.

- una volta scaricato unetbootin, installatelo e, se la vostra distro si è scaricata, collegate la pen drive vuota (formattata in FAT32) e avviate unetbootin. Selezionate l'iso scaricata ed il dispositivo di montaggio dell'ISO (vedi immagini sotto spoiler) ed avviate (le immagini sono prese dalla mia guida per installare android x86 su pc, cambiano i file, ma il processo è identico.

Spoiler:

http://i.imgur.com/oknkf9I.pnghttp://i.imgur.com/8SUyV3T.pnghttp://i.imgur.com/NCtFSio.pnghttp://i.imgur.com/5oowwLO.png

Una volta che la pen drive è pronta (ci vorranno 2-5 minuti a seconda della potenza del vostro pc), riavviate e selezionate dal menu di boot la vostra pen drive. Si avvierà una finestra blu che vi chiederà se volete provare o installare Ubuntu. Selezionate l'installazione, che vi porterà ad una procedura guidata estremamente semplice. Arrivati ad un certo punto, vi chiederà se volete installare Ubuntu da solo sul pc, o se volete affiancarlo a Windows/Mac OS, qui sta a voi decidere, l'importante è che riserviate ad Ubuntu almeno 150gb (vedremo dopo perché).
Procedete con l'installazione assegnando come file system ext4 (è già disponibile il nuovo btfrs, ma non è ancora stabile). Decidete anche il vostro nome utente e la vostra password (consiglio di usare una parola abbastanza corta poiché dovrete inserire spesso la password nel terminale).

Nel giro di una ventina di minuti o poco più (sempre a seconda del vostro pc) avrete Ubuntu installato sulla vostra macchina.

Appena entrati su Ubuntu, corriamo subito ad aggiornare i pacchetti esistenti aprendo il terminale (ctrl+alt+t) e immettendo i seguenti comandi:

codice:

---

sudo apt-get update
sudo apt-get dist-upgrade

---

Giusto il tempo di scaricare gli aggiornamenti (in genere mai più di 300mb), di installarli ed il sistema è pronto. Per sicurezza riavviate.

Installazione pacchetti essenziali

In questo momento avete un sistema operativo basilare, aggiornato e funzionale, ma non ancora pronto ad ospitare il processo di building. Ci servono alcuni pacchetti e li installiamo sempre da terminale. Potete copipastare i comandi che vi do, onde evitare errori.

Installiamo i codec e le librerie multimediali:

codice:

---

sudo apt-get install ubuntu-restricted-extras

---

codice:

---

sudo wget --output-document=/etc/apt/sources.list.d/medibuntu.list http://www.medibuntu.org/sources.list.d/$(lsb_release -cs).list && sudo apt-get --quiet update && sudo apt-get --yes --quiet --allow-unauthenticated install medibuntu-keyring && sudo apt-get --quiet update

---

codice:

---

sudo apt-get install libdvdcss2

---

Installiamo il tool per aprire una finestra di terminale in una cartella con un click:

codice:

---

sudo apt-get install nautilus-open-terminal

---

Ci servirà per risparmiare tempo, invece di recarci col comando cd.

[PROSEGUO AL POST #2]

Installazione dei pacchetti necessari

Prima di installare alcuni pacchetti fondamentali, creiamo le regole di accesso alle porte usb per i device.
Da terminale date il comando per aprire come root gedit, un potente editor di testo e creare un file nel percorso /etc/udev/rules.d:

codice:

---

sudo gedit /etc/udev/rules.d/51-android.rules

---

Ora copiate ed incollate il seguente testo nel vostro editor:

codice:

---

# adb protocol on passion (Nexus One)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e12", MODE="0666", OWNER="klaasmad"
# fastboot protocol on passion (Nexus One)
SUBSYSTEM=="usb", ATTR{idVendor}=="0bb4", ATTR{idProduct}=="0fff", MODE="0666", OWNER="klaasmad"
# adb protocol on crespo/crespo4g (Nexus S)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e22", MODE="0666", OWNER="klaasmad"
# fastboot protocol on crespo/crespo4g (Nexus S)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e20", MODE="0666", OWNER="klaasmad"
# adb protocol on stingray/wingray (Xoom)
SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", ATTR{idProduct}=="70a9", MODE="0666", OWNER="klaasmad"
# fastboot protocol on stingray/wingray (Xoom)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="708c", MODE="0666", OWNER="klaasmad"
# adb protocol on maguro/toro (Galaxy Nexus)
SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", ATTR{idProduct}=="6860", MODE="0666", OWNER="klaasmad"
# fastboot protocol on maguro/toro (Galaxy Nexus)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e30", MODE="0666", OWNER="klaasmad"
# adb protocol on panda (PandaBoard)
SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d101", MODE="0666", OWNER="klaasmad"
# fastboot protocol on panda (PandaBoard)
SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d022", MODE="0666", OWNER="klaasmad"
# usbboot protocol on panda (PandaBoard)
SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d00f", MODE="0666", OWNER="klaasmad"
# usbboot protocol on panda (PandaBoard ES)
SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d010", MODE="0666", OWNER="klaasmad"
# adb protocol on grouper (Nexus 7)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e42", MODE="0666", OWNER="klaasmad"
# fastboot protocol on grouper (Nexus 7)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e40", MODE="0666", OWNER="klaasmad"
# mtp protocol on the grouper (Nexus 7)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e41", MODE="0666", OWNER="klaasmad"
## Google
#SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4ee2", MODE="0666", OWNER="klaasmad"
## LG Nexus 4
SUBSYSTEM=="usb", ATTR{idVendor}=="1004", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="0bb4", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="0502", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="12d1", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="1004", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="22b8", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="04e8", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="0fce", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="0489", MODE="0666", OWNER="klaasmad"

SUBSYSTEM=="usb", ATTRS{idVendor}=="18d1", SYMLINK+="android_adb", MODE="0666"

SUBSYSTEM=="usb", ATTRS{idVendor}=="04e8", MODE="0666", GROUP="plugdev"
# Google Nexus 7 MTP mode : automatic mount when plugged (all android versions)
ENV{ID_MODEL}=="Nexus_4", ENV{ID_MODEL_ID}=="4ee2", ACTION=="add", RUN+="/usr/bin/sudo -b -u yourlogin /usr/local/sbin/go-mtpfs -allow-other=true /media/Nexus4"
ENV{ID_MODEL}=="Nexus_4", ENV{ID_MODEL_ID}=="4ee2", ACTION=="add", RUN+="/usr/bin/sudo -b -u yourlogin /usr/local/sbin/go-mtpfs -allow-other=true /media/Nexus4"
ENV{ID_MODEL}=="Nexus_7", ENV{ID_MODEL_ID}=="4e41", ACTION=="add", RUN+="/usr/bin/sudo -b -u yourlogin /usr/local/sbin/go-mtpfs -allow-other=true /media/Nexus7"
ENV{ID_MODEL}=="Nexus_7", ENV{ID_MODEL_ID}=="4e42", ACTION=="add", RUN+="/usr/bin/sudo -b -u yourlogin /usr/local/sbin/go-mtpfs -allow-other=true /media/Nexus7"

# Google Nexus 7 MTP mode : automatic unmount when unplugged (all android versions)
ENV{ID_MODEL}=="Nexus_4", ENV{ID_MODEL_ID}=="4ee2", ACTION=="remove", RUN+="/bin/umount /media/Nexus4"
ENV{ID_MODEL}=="Nexus_4", ENV{ID_MODEL_ID}=="4ee2", ACTION=="remove", RUN+="/bin/umount /media/Nexus4"
ENV{ID_MODEL}=="Nexus_7", ENV{ID_MODEL_ID}=="4e41", ACTION=="remove", RUN+="/bin/umount /media/Nexus7"
ENV{ID_MODEL}=="Nexus_7", ENV{ID_MODEL_ID}=="4e42", ACTION=="remove", RUN+="/bin/umount /media/Nexus7"

---

Cliccate sulla lente di ingrandimento e la matita nella barra degli strumenti e sostituite la parola "klaasmad" (mio nome utente) con il vostro nome utente. Salvate il file ed uscite.

Installate i pacchetti chiave per settare l'ambiente:

codice:

---

sudo apt-get install git-core 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 openjdk-6-jdk tofrodos python-markdown libxml2-utils xsltproc zlib1g-dev:i386

---

Dopo che ha terminato l'installazione, date:

codice:

---

sudo ln -s /usr/lib/i386-linux-gnu/mesa/libGL.so.1 /usr/lib/i386-linux-gnu/libGL.so

---

Dopo di ché, continuate dando da terminale:

codice:

---

sudo apt-get install schedtool pngcrush

---

Alcune modifiche essenziali

Scarichiamo i binari del programma repo, diamogli i permessi necessari ed inseriamolo nel path di esecuzione.

Aprite un nuovo terminale e date:

codice:

---

mkdir ~/bin

---

Aggiungete la cartella ~/bin nel path dando:

codice:

---

PATH=~/bin:$PATH

---

Scaricate ora i binari di repo ed inseriteli nella cartella bin dando:

codice:

---

curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo

---

Dategli i permessi:

codice:

---

chmod a+x ~/bin/repo

---

Repo è ora installato! Non ci resta che preparare il nostro percorso di download dei sorgenti ed abbiamo terminato!

Percorso dei sorgenti

Per comodità, sono solito scaricare 5-6 sorgenti diversi per ogni ROM, non tanto perché buildo ogni ROM che mi torna in mano, ma quanto perché confronto spesso i sorgenti di questa ROM con quelli di un'altra (e servirà anche a voi, fidatevi!). Allora è opportuno creare un buon set di cartelle dove operare.
Questa è la mia struttura, voi siete liberi di piazzarle dove volete, è solo per darvi una linea guida:

Da terminale (ma potete farlo anche da GUI) date:

codice:

---

mkdir ~/sorgenti && cd ~/sorgenti

---

Con questo comando creeremo la cartella sorgenti e ci entreremo. Notate il nome minuscolo. Da un esponente ragionevolmente malato di OCD, è un bel pugno nello stomaco, ma vi servirà quando dovrete digitare velocemente da terminale ed il tempo per premere lo shift, sarà un'eternità.

Quando dovrete scaricare dei sorgenti, vi verrà chiesto di creare una cartella in base al nome della ROM:

- cm per CyanogenMod (anche se di solito la struttura che usano è ~/android/system)
- aokp per le AOKP
- slim per le SlimROM

etc etc. Ero solito averle tutte nella home, con conseguente disordine. Così è tutto molto più ordinato e strutturato.

Ora, per onor di cronaca non ufficiale, vi consiglierei di scaricare i sorgenti della CyanogenMod, sia perché ha la struttura di compilazione e build più semplice, sia perché è la ROM alla quale TUTTE QUANTE LE ALTRE ROM fanno riferimento, visto che praticamente i device tree, ossia la struttura di codice degli specifici smartphones, appartiene al team CM.

[PROSEGUO AL POST #3]

Download dei sorgenti CyanogenMod

Vediamo, anche come esempio di massima, con scaricare i sorgenti CyanogenMod (senza riferimento a particolari devices).
Innanzitutto recatevi alla pagina github del team che potete trovare su github.com/CyanogenMod.

Cercate il loro platform_manifest, di solito rinominato così nei sorgenti comuni, ma CyanogenMod ha una denominazione particolare, si chiama infatti android.

Lì potrete trovare i comandi per scaricare i sorgenti, in questo caso, essendo la vostra prima volta, ve li scrivo io (devono essere eseguiti da terminale):

codice:

---

cd sorgenti
mkdir cyanogenmod
cd cyanogenmod

---

Questi comandi ci serviranno a creare la cartella ~/sorgenti/cyanogenMod dove andremo a piazzare i sorgenti. Digitiamo da terminale:

codice:

---

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

---

Fermiamoci un attimo a guardarli, possiamo riconoscere 3 parti fondamentali, vediamo cosa significano:

- [repo init -u] possiamo riconoscere repo, il programma in python che abbiamo scaricato e che abbiamo settato nel path ~/bin/repo
- [git://github.com/CyanogenMod/android.git] è l'indirizzo del manifest di CyanogenMod seguito da .git, il formato che viene compreso dal tool repo
- [-b cm-10.2] è invece il branch (la b iniziale sta per branch), ossia il ramo che vogliamo scaricare che è, per l'appunto, cm-10.2 (android 4.3).

In questo modo scaricheremo alcuni file basilari per il download vero e proprio. Per verificare cosa abbiamo scaricato, riduciamo ad icona il terminale ed apriamo il file manager (cliccando nell'archivio nella barra laterale) e andiamo fisicamente nella cartella ~/sorgenti/cyanogenmod. Non vedremo nulla, perché la cartella che è stata creata è nascosta. Per vederla basterà eseguire la combinazione di tasti ctrl + h. Spunterà una cartella chiamata .repo (il punto davanti la prima parola nasconde la cartella in Linux). Entrateci e cliccate su manifests. Ci sarà un documento chiamato default.xml apritelo (tasto destro del mouse, apri con gedit) e spulciatelo. Quelli sono gli indirizzi dei vostri sorgenti. Non toccate nulla e non salvate quando chiudete il documento.
Tornate al vostro terminale ridotto ad icona e diamo, come ultimo comando

codice:

---

repo sync

---

Il comando repo ormai lo conoscete. Sync sta per synchronize, sincronizzazione. Difatti il terminale comincerà un download frenetico dei vostro sorgenti che possono variare dagli 8gb ai 16gb.
È possibile impostare un'opzione per velocizzare il download usando l'opzione -jX (j sta per jobs e la X sta per un valore numerico, tanto più alto, quanto più veloce).
Esempio:

codice:

---

repo sync -j32

---

È lecito pensare che valori più alti indurranno un download più veloce. Sarebbe anche così se non fosse che le connessioni italiane sono scadenti, per cui scaricare 8gb significherà comunque aspettare almeno 5-6 ore, almeno!
Comunque, di suo, è impostato per scaricare con 4 jobs (lo potete vedere nel default.xml che abbiamo aperto poco sopra), per cui il numero di jobs è implicito nel comando che date.

Dopo che terminate il download avrete i vostri sorgenti, ma come si builda lo vedremo un'altra volta!

Riservato #1

Riservato #2

Riservato #3

Quoto tutto a prescindere.....

Domani (da sobrio) me la leggo:D:D:D;)

Quote:

---

Originariamente inviato da N1m0Y

Quoto tutto a prescindere.....

Domani (da sobrio) me la leggo:D:D:D;)

---

Ahahah ripigliati N1m0y :D

questo è quello che mi dice quando metto il codice

codice:

---

samulomba96@samulomba96-Aspire-M1610:~$ sudo wget --output-document=/etc/apt/sources.list.d/medibuntu.list http://www.medibuntu.org/sources.list.d/$(lsb_release -cs).list && sudo apt-get --quiet update && sudo apt-get --yes --quiet --allow-unauthenticated install medibuntu-keyring && sudo apt-get --quiet update
[sudo] password for samulomba96:
--2015-01-23 16:50:01--  http://www.medibuntu.org/sources.list.d/trusty.list
Risoluzione di www.medibuntu.org (www.medibuntu.org)... non riuscito: Nome o servizio sconosciuto.
wget: impossibile risolvere l'indirizzo dell'host "www.medibuntu.org"
samulomba96@samulomba96-Aspire-M1610:~$

---

Come ho accennato altrove sto provando ad imparare...
Uso OpenSUSE e non ubuntu, hai esperienza di questa distribuzione? qualche sito da cui prelevare i tools?

grazie

Paolo

P.S. sto scaricando la Cyan. per ora sono a 5 GB, spero di finire entro stasera.
Nel frattempo ho fatto i passaggi di configurazione, sotto opensuse alcune delle librerie richieste sono già installate, di altre non risulta nessun equivalente...
C'è un pacchetto, una sequenza di comandi per verificare rapidamente se c'è tutto quello che serve?