DIY : compiler une ROM Android à partir du code source

Android est le système d'exploitation mobile le plus utilisé au monde. Et la meilleure partie, c'est complètement open-source, ce qui en termes simples, signifie que le code source, le programme réel est disponible ouvertement pour que chacun puisse télécharger, personnaliser et créer ses propres ROM.

Il existe de nombreuses distributions Android personnalisées disponibles, les plus populaires étant CyanogenMod, SlimROM, Paranoid Android, AOKP, Liquid Smooth, MIUI, Xylon, Ice Cold Jelly, etc.

Pour le guide d'aujourd'hui, nous allons compiler CyanogenMod 10.2, la ROM de rechange Android la plus populaire. La procédure est à 99% la même pour toutes les ROM personnalisées, ce guide peut donc également être utilisé comme référence pour compiler d'autres ROM.

Conditions préalables

1. Un téléphone Android avec un noyau et une source de périphérique facilement disponibles, déjà enracinés et avec une récupération personnalisée installée.
2. Distribution Linux 64 bits (Nous préférons Ubuntu).
3. Au moins 100 Go gratuits sur votre disque dur.
4. Connaissance pratique des commandes de terminal Linux.
5. Connexion Internet assez rapide.

Point à noter: Le système d'exploitation Linux 64 bits est indispensable, et il doit s'agir d'une installation native, pas d'une machine virtuelle.

Configurer votre machine de construction

1. Installez le système d'exploitation Linux de votre choix : Version 64 bits, selon les instructions officielles. (Le guide supposera que nous exécutons Ubuntu 13.04). Conservez une partition d'au moins 100 Go avec une partition d'échange de 16 Go.

2. Installez la liste de packages suivante : Ouvrez l'application Terminal et tapez

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

appuyez sur Entrée et il vous demandera votre mot de passe.

Liste des paquets

[html]
git-core
Gnupg
fléchir
bison
python
rar
original-awk
rester bouche bée
p7zip-plein
gperf
libsdl1.2-dev
libesd0-dev
libwxgtk2.6-dev
outils squashfs
build-essentiel
Zip *: français
boucle
libncurses5-dev
zlib1g-dev
pngécraser
outil de planification
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. Installez Java JDK 1.6 pour Linux 64 bits : Le nom du fichier doit être jdk-6u##-linux-x64.bin, ## sont les numéros de version. Déplacez le package téléchargé vers votre répertoire personnel. Ouvrez l'application Terminal et exécutez l'ensemble de commandes suivant :

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

Maintenant, nous devons ajouter JDK Path à .bashrc

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

Ajoutez ces lignes à la fin du fichier texte

[html]
# Chemin Java
exporter JAVA_HOME=/opt/java/64/jdk1.6.0_##
export CHEMIN=$CHEMIN:$JAVA_HOME/bin
[/ Html]

4. Installez le SDK Android : Ouvrir l'application Terminal

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

Téléchargez le SDK Android depuis http://developer.android.com/sdk/index.html. Extrayez le contenu du package dans ~/android/sdk Nous devons ajouter le chemin du SDK Android à .bashrc

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

Ajoutez ces lignes à la fin du fichier texte :

[html]
# Chemin du SDK Android
export CHEMIN=$CHEMIN:~/android/sdk
export PATH=$PATH:~/android/sdk/platform-tools
export PATH=$PATH:~/android/sdk/tools
[/ Html]

Maintenant, installez Android SDK Tools en tapant

[html]
android
[/ Html]

5. Configurez votre compte github et votre dépôt distant : Vous pouvez ignorer cette étape si CyanogenMod prend officiellement en charge votre téléphone. Allez sur github.com et créez un compte pour vous-même. Pour ce guide, je considère votre nom d'utilisateur comme « utilisateur ».

Visitez 'github.com/CyanogenMod/android', appuyez sur Fork. Le manifeste à distance sera bifurqué et disponible dans votre référentiel personnel.

Maintenant, allez sur 'github.com/user/android'. Ouvrez le fichier default.xml, appuyez sur Modifier. Trouvez cette ligne :

[html]

[/ Html]

Et remplacez-le par

[html]

[/ Html]

Je considère que la source du noyau de votre appareil, la source de l'appareil et les bibliothèques du fournisseur pour Android 4.3 sont à

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

Je suppose que la branche s'appelle 'jb4.3'. Vous pouvez trouver le nom exact dans le dépôt réel. Puis, à la fin du fichier, ajoutez ces lignes en les modifiant selon le code source de votre appareil.

[html]




[/ Html]

Validez vos modifications. Votre manifeste distant est prêt à être déployé.

6. Installez la commande Repo : Ouvrez le Terminal et tapez

[html]
cd ~
mkdir ~ / bin
boucle https://dl-ssl.google.com/dl/googlesource/git-repo/repo > ~/bin/repo
chmod a+x ~/bin/dépôt
[/ Html]

Nous devons ajouter le chemin Repo à .bashrc

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

Ajouter cette ligne à la fin du fichier texte

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

7. Récupérez le code source de la ROM : Ouvrez le Terminal et tapez

[html]
mkdir ~/android/cm
cd ~/androïde/cm
[/ Html]

Si vous avez besoin de l'étape 5, tapez

[html]
dépôt init –u git://github.com/user/android.git –b cm-10.2
[/ Html]

Si votre appareil prend officiellement en charge CyanogenMod 10.2, tapez

[html]
dépôt init –u git://github.com/CyanogenMod/android.git –b cm-10.2
[/ Html]

Maintenant courez

[html]
synchronisation du référentiel –j16
[/ Html]

Allez prendre un café ou un repas, ça va être long. Le code source a une taille bien supérieure à 10 Go, cela prendra donc un certain temps.

8. Configurez les éléments spécifiques à l'appareil : Si votre appareil prend officiellement en charge CyanogenMod 10.2, ouvrez Terminal et tapez

[html]
cd ~/androïde/cm
. build/envsetup.sh && petit déjeuner
[/ Html]

Cela prendra un certain temps, la source de l'appareil a une taille d'environ 3 Go. Ensuite, vous devez avoir installé CM10.2 officiel sur votre téléphone, le connecter à votre PC en mode de débogage USB et exécuter les commandes suivantes :

[html]
racine adb
cd ~/android/cm/appareil/ / /
./extraire-fichiers.sh
[/ Html]

Si votre appareil ne prend pas officiellement en charge CyanogenMod 10.2, alors vous n'avez rien à faire dans cette étape, les sources vous attendent déjà.

9. Téléchargez les éléments prédéfinis et configurez la chaîne d'outils : Ouvrez le Terminal et tapez

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

Maintenant, nous devons ajouter le PATH de la chaîne d'outils à ./bashrc

[html]
cd ~/androïde/cm
sudo gedit ~ / .bashrc
[/ Html]

Ajoutez ces lignes à la fin du fichier texte

[html]
# Chaîne d'outils Android
exporter ARCH=bras
exporter CCOMPILE=$CROSS_COMPILE
export CROSS_COMPILE=bras-eabi-
export PATH=$PATH:~/android/cm/prebuilt/linux-x86/toolchain/arm-eabi-4.4.3/bin
[/ Html]

10. Construisez votre ROM : Donc, tout va bien et prêt. Il est temps de construire la ROM. Ouvrez le terminal et tapez

[html]
cd ~/androïde/cm
. build/envsetup.sh
brunch
[/ Html]

Il est temps d'aller faire une sieste. Il faudra des millions d'années pour construire la ROM sur un ordinateur moyen. Eh bien, c'était une exagération, mais sur mon PC à la maison (Core i5 2e génération avec 8 Go de RAM), il faut plus de 3 heures pour construire à partir de zéro. Espérons qu'il n'y aura pas d'erreurs et que la construction se terminera correctement. Vous obtiendrez le package de sortie dans

[html]
~/android/cm/out/cible/produit/ /cm-10.2-quelque chose-UNOFFICIEL- .Zip *: français
[/ Html]

Il est temps d'installer votre ROM nouvellement compilée sur votre téléphone. Téléchargez le package Google Apps sur « www.goo.im/gapps » pour la version Android appropriée. Mettez ces deux packages dans votre téléphone et flashez-les en mode de récupération. Voila, votre propre ROM compilée exécute maintenant votre appareil.

Eh bien, vous avez donc appris à compiler une ROM. Et maintenant?

Mettez à jour votre ROM source

Pour récupérer les nouvelles mises à jour du code source de votre code source téléchargé localement, ouvrez Terminal et tapez

[html]
cd ~/androïde/cm
synchronisation du référentiel –j16
[/ Html]

Pour construire votre ROM, après avoir mis à jour le code source, ouvrez le terminal et tapez

[html]
cd ~/androïde/cm
faire installer propre
find ./out/ -name 'build.prop' | xargs rm
find ./out/ -name 'cm_ -target_files-eng.*.zip' | xargs rm
. build/envsetup.sh
brunch
[/ Html]

Puisque vous ne reconstruisez pas à partir de zéro, mais reconstruisez tel quel, cela prendra beaucoup moins de temps, seulement environ 15-30 minutes dans la plupart des cas. Vous devez synchroniser votre source locale toutes les semaines environ, pour garder votre source locale à jour.

Nettoyez votre répertoire de travail

Pour nettoyer complètement votre répertoire de travail (lire : remettre votre dossier source à l'état de stock), ouvrez Terminal et tapez les commandes suivantes.

[html]
cd ~/androïde/cm
faire installer propre
faire de la triche
[/ Html]

Gardez à l'esprit qu'après avoir exécuté ces commandes, toutes vos données de sortie seront supprimées, donc la prochaine génération prendra à nouveau 3 à 4 heures, car tout est reconstruit à partir de zéro. Si votre partition de disque dur est petite, disons environ 100 Go, vous devez nettoyer votre répertoire de travail environ une fois toutes les 4 versions, sinon vous manquerez d'espace sur le disque dur.

Accélérez votre build par CCACHE

Construire une ROM prend beaucoup de temps. Mais le temps peut être réduit d'environ 30 à 45 % en utilisant CCACHE. CCACHE signifie cache du compilateur, il met en cache la sortie de compilation de vos versions précédentes, afin qu'elle puisse être réutilisée dans des versions ultérieures.

Notez que CCACHE a besoin de beaucoup d'espace sur votre disque dur pour mettre en cache le contenu, il est donc recommandé si et seulement si votre partition de disque dur est quelque part dans les environs de 200 Go ou plus. Pour configurer CCACHE, ouvrez Terminal et tapez :

[html]
cd ~/androïde/cm
exporter USE_CCACHE=1
exporter CACHE_DIR=~/.ccache
préconstruits/misc/linux-x86/ccache/ccache –M 50G
[/ Html]

Vous pouvez modifier l'allocation de taille maximale à CCACHE de 50 Go à ce que vous voulez, mais un minimum d'environ 30 Go doit être utilisé pour de bons résultats.

Récupérer les commits d'autres ROM

Vous pouvez sélectionner des fonctionnalités à partir du code source d'autres ROM. Disons, par exemple, que je veux choisir la fonctionnalité A, avec l'ID de validation "12345" du référentiel "github.com/user/reporepo".

Vous accédez au package dans votre code source local et les exécutez dans Terminal.

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

Liens de code source de célèbres distributions de ROM personnalisées Android

CyanogenMod – https://github.com/CyanogenMod
SlimROM – https://github.com/SlimRoms
ParanoidAndroid – https://github.com/ParanoidAndroid
AOKP – https://github.com/AOKP
LiquideLisse – https://github.com/liquidsmooth
ROM Xylon -
Gelée glacée – https://github.com/IceColdJelly

Alors, voilà les gars, un guide simple et direct pour compiler pratiquement n'importe quelle ROM basée sur Android AOSP en 10 étapes simples. Alors que mon guide se concentre sur CyanogenMod, vous pouvez compiler à peu près toutes les ROM AOSP, en modifiant simplement les liens du référentiel. Ou, vous pouvez simplement choisir des fonctionnalités, les valider, modifier des éléments et créer votre propre ROM personnalisée, peut-être aussi partager votre ROM en ligne ?