[TUTO] Compiler soi même une ROM Nexus 4

[Okaryn]

Bonjour à tous,

 

Voici un petit tutoriel pour vous apprendre à compiler vous-même les sources d'une ROM pour notre Nexus 4. La manipulation n'est en fait pas spécifique au N4, c'est juste un prétexte pour rester dans notre section ;)

 

Pour ce tutoriel, je me base sur les sources Slimbean. Si vous souhaitez compiler une autre ROM il faudra ajuster en conséquence car certaines sont plus compliquées. Reportez-vous aux sujets sur XDA ou sur les forums de la ROM pour en savoir plus.

 

Tout d'abord je tiens à remercier El Liberator qui m'a mis le pied à l'étrier avec un premier tutoriel, un sujet sur XDA, la documentation Google ainsi que tous ceux qui ont rédigés des sujets ou apportés des réponses sur différents forums.

 

Le sujet sera amené à évoluer, au fur et à mesure que j'avancerai dans mes découvertes ou que d'autres personnes prendront les temps de prodiguer conseils, astuces, etc...

 

Nous commencerons tout d'abord par une compilation basique puis par la suite en ajoutant la compilation avec le toolchain Linaro. Commencez par cette compilation simple avec de vouloir passer à la suite (comme ça, cela me laisse le temps de rédiger la suite :P )

 

Pour ce tutoriel, je me base sur les sources Slimbean.

 

 

1/ Installation de l'OS

 

Pour compiler, il faut un système Linux en 64 bits. Prenons donc Ubuntu 13.10 64 bits, que vous pourrez télécharger ici

 

Vous pouvez l'installer à côté de votre OS actuel (windows) ou bien dans une machine virtuelle, comme par exemple VirtualBox. Si vous utilisez VirtualBox, il faudra prévoir 100 Go d'espace disque puis appliquer les extensions VirtualBox une fois Ubuntu installé.

 

Si vous utilisez une autre distribution, reportez-vous au message de Minux pour les préconisations de version des outils.

 

2/ Installation des paquets nécessaires

 

Une fois l'OS installé, il faut lui ajouter des composants qui permettront de compiler correctement les sources.

 

Toutes les commandes devront être saisies dans le Terminal, pour y accéder, cliquez sur l'icone en haut à gauche de l'écran (rechercher un programme), saisissez "Terminal" puis cliquez sur l'icône correspondante :

 

 

Tout d'abord un coup de ménage pour virer les précédentes installation d'Open JDK qui n'est pas recommandé.

 

Saisissez la commande suivante et validez

sudo apt-get purge openjdk-\* icedtea-\* icedtea6-\*

Installons ensuite le JDK 6 d'Oracle (la version 7 ne fonctionne pas) avec les 2 commandes suivantes :

sudo add-apt-repository ppa:webupd8team/java 
sudo apt-get update
sudo apt-get install oracle-java6-installer

Une fois l'installation terminée, vérifiez que tout est OK à l'aide la version de Java :

java -version

Vous devriez voir quelque chose comme cela, avec la version de JAVA (1.6.0) et le dernier update pack (45 au moment où je rédige) : 

java version "1.6.0_45" 
Java(TM) SE Runtime Environment (build 1.6.0_45-b06) 
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode) 

Passons ensuite à tous les petits composants supplémentaires, il s'agit de 3 lignes différentes pour être compatible ave cla version 14.04 d'Ubuntu :

sudo apt-get install git-core gnupg flex bison gperf build-essential zip curl 

sudo apt-get install zlib1g-dev zlib1g-dev:i386 libc6-dev lib32ncurses5-dev x11proto-core-dev libx11-dev:i386 

sudo apt-get install libreadline6-dev:i386 lib32z-dev libgl1-mesa-glx:i386 libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown libxml2-utils xsltproc readline-common libreadline6-dev libreadline6 lib32readline-gplv2-dev libncurses5-dev lib32readline5 lib32readline6 libreadline-dev libreadline6-dev:i386 libreadline6:i386 bzip2 libbz2-dev libbz2-1.0 libghc-bzlib-dev lib32bz2-dev libsdl1.2-dev libesd0-dev squashfs-tools pngcrush schedtool libwxgtk2.8-dev python lzop ccache

**Astuce : pour Ubuntu 13.04 uniquement ajoutez ceci :

sudo apt-get install ia32-libs

Une fois que tout est installé, saisissez la commande suivante (ce que l'on appelle un lien symbolique afin de créer un faux fichier qui correspond à un fichier existant) :

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

Maintenant installons l'outils repo qui permet de se connecter aux sources de notre ROM. Il s'agit d'un outil que l'on récupère sur le site de Google et que l'on rend 'exécutable' avec la commande chmod (il s'agit en fait d'un simple fichier de commandes) :

mkdir ~/bin
curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo

Comme il est installé à un endroit qui n'est pas connu par le système (~/bin/) nous devons ajouter ce répertoire à la variable d'environnement. Nous allons donc éditer un fichier système :

sudo gedit ~/.bashrc

Nous allons en profiter pour également activer le cache de compilation, qui permettra de réduire le temps de compilation les fois suivantes.

 

Allez à la fin du fichier, ajoutez une ligne blanche puis insérez les 2 lignes suivantes :

export PATH=~/bin:$PATH
export USE_CCACHE=1

Enregistrez le fichier et quittez gedit. Pour prendre en compte la modification immédiatement (évite de redémarrer Ubuntu) saisissez :

source ~/.bashrc

Vous pouvez régler la taille du cache, en utilisant la commande suivante (remplacez 50G par une valeur plus grande si vous voulez ou si vous compilez plusieurs ROM) :

ccache -M 50G

**Astuce : Pour voir l'utilisation de votre cache (appuyez ensuite sur Ctrl+z pour stopper la visualisation en temps réel) :

ccache -s

3/ Récupération des sources

 

Avant de tout récupérer, il faut paramétrer git (l'outils de gestion des sources appelé par repo) avec vos coordonnées mail et nom, cela se fait avec les 2 commandes suivantes :

git config --global user.email "votre@email.fr"
git config --global user.name "votre_pseudo"

Nous allons maintenant créer un nouveau répertoire qui contiendra les sources de notre ROM, puis nous nous placerons dedans :

mkdir ~/slim
cd ~/slim

Ensuite, nous allons indiquer à repo que nous allons travailler sur les sources de la Slimbean (en image, le code ne passe pas) pour tout ce qui se trouve dans le répertoire ~/slim :

 

 

Pour faire un copier/coller, voici la balise de code mais avec un espace en plus entre les 2 "/" qu'il faut supprimer :

repo init -u git:/ /github.com/SlimRoms/platform_manifest.git -b jb4.3

 

**Astuce : si vous avez déjà les sources d'une ROM, vous pouvez gagner du temps en évitant de télécharger ce qui est commun à l'autre ROM en ajoutant le paramètre "--reference=...".

 

Exemple si vous avez les sources dans un répertoire "~/aosp" (toujours en image) :

 

Voilà, nous sommes prêts à lancer la récupérations des sources. Il y a pas moins de 8 Go à récupérer, il vous faudra donc du temps (presque 4H avec ma connexion à 500Ko/s), vous comprenez maintenant le pourquoi de l'astuce ci-dessus. Saisissez donc :

repo sync -j4

La fin de la ligne "-j4" indique le nombre de tâches en simultanées, 4 état la valeur par défaut. Selon votre débit et votre processeur, vous pouvez mettre un plus grand nombre comme "j-16". Attention toute fois à ne pas saturer votre débit.

 

Voilà, nous venons de récupérer les sources génériques de la SlimBean, maintenant il faut lui indiquer que l'on souhaite travailler sur la version Nexus 4 afin qu'il récupère la partie spécifique à notre téléphone :

. build/envsetup.sh
lunch slim_mako-userdebug

**Astuce : vous pouvez choisir un autre téléphone car les sources SlimBean sont pour plusieurs appareils, saisissez simplement lunch et vous aurez droit à un menu avec tous les appareils supportés.

 

4/ Lancer la compilation

 

Nous y sommes presque ! Il ne reste plus qu'à lancer toute la compilation avec...

make bacon -j4

**Astuce : Comme pour la commande repo, la paramètre "-j4" indique le nombre de tâches. Vous pouvez le définir entre 1 et 2 fois le nombre de processeurs logiques. Par exemple, sur un intel i7, 4 coeurs physiques et 8 logiques (2 threads par coeur en réalité), vous saisirez donc une valeur comprise entre "make bacon -j8" et "make bacon -j16" (2 * 8). Mettre un nombre trop grand ne servira à rien (sous ma VM Linux -J8 et -J16 donnent le même temps de compilation). A vous de voir ce qui permet une meilleure compilation (attention à ne pas comparer les temps avec la 1ère compilation qui ne tient pas compte du cache).

 

Soyez patient et vous trouverez le résultat de votre compilation directement sous forme de .ZIP dans le répertoire "~/slim/out/target/product/mako/". Exemple : "Slim-mako-4.3.build.1.8-UNOFFICIAL-20131019-1724.zip".

 

Si vous n'obtenez pas de fichier .ZIP alors qu'il n'y a d'erreur, peut être que vos sources utilisent une autre variante de compilation, essayez :

make otapackage -j4

Ou bien, comme pour la PSX les 2 commandes suivantes :

make -j4
make dist -j4

Pensez à supprimer le répertoire "~/slim/out" avant de lancer la compilation suivante.

 

Pour un ordre de grandeur, il me faut 1h45 sous VirtualBox hébergé sur un ancien i7 sous Windows 8 (avec l'option -j8), et 2h30 sur un portable i5 4 Go de RAM avec Ubuntu natif (avec l'option -j8 également). Une seconde compilation ne me prend que 55 minutes grâce à l'activation du cache.

 

5/ Compilation Linaro

 

Vous avez réussi la première étape, à savoir compiler normalement les sources. Nous pouvons donc passer à la première optimisation : utiliser le Toolchain Linaro :)

 

Avec votre navigateur, allez sur http://releases.linaro.org et téléchargez la dernière version qui se trouve dans une arborescence ressemblant à :[/size]

/13.09/components/android/toolchain/

Le numéro de version "13.09" évolue tous les mois, mais il ne contient pas forcément la partie "/components/android/toolchain/", dans ce cas il faut prendre la version précédent. Au 20/10/2013 il existe par exemple le répertoire "13.10", mais ce dernier ne comprend pas le sous-répertoire "/components/android/", on se rabat donc sur la version 13.09

 

Là vous aurez droit à plusieurs autres versions qui correspondent au compilateur GCC utilisé par le Toolchain, exemple "4.7" et "4.8". Prenez de préférence la dernière version, puis téléchargez le fichier qui se termine par ".tar.bz2" :

http://releases.linaro.org/13.09/components/android/toolchain/4.8/android-toolchain-eabi-4.8-2013.09-x86.tar.bz2

**Astuce : sauvegardez le fichier, n'essayez pas de l'ouvrir avec le gestionnaire d'archive.

 

Par défaut sous FireFox le fichier sera sauvegardé dans votre répertoire "~/Téléchargements/". Nous allons ensuite le déplacer là où se trouvent les Toolchain, le décompresser en .tar, décompresser ensuite le .tar et supprimer notre fichier téléchargé :

cd ~/slim/prebuilts/gcc/linux-x86/arm/
mv ~/Téléchargements/android-toolchain-eabi-4.8-2013.09-x86.tar.bz2 .
bunzip2 *.tar.bz2
tar -xvf *.tar
rm *.tar

**Astuces :

Faites bien attention à saisir "prebuilts" avec "s" à la fin, il existe un répertoire sans le "s"

N'oubliez pas le point "." à la fin de la deuxième instruction, ça indique de déplacer le fichier dans le répertoire où l'on se trouve

Dans une session Terminal, appuyez sur la touche tabulation pour compléter automatiquement le nom des répertoires et des fichiers

 

Nous devons ensuite modifier le fichier de compilation pour lui indiquer d'aller chercher le Toolchain Linaro à la place de celui habituel.

cd ~/slim
gedit build/envsetup.sh

Rechercher (ctrl + f) la chaîne de caractère "toolchaindir=arm/arm-linux-androideabi", puis remplacer la ligne

arm) toolchaindir=arm/arm-linux-androideabi-$targetgccversion/bin

par

arm) toolchaindir=arm/android-toolchain-eabi/bin

Voici ce que cela donne dans gedit après modification :

 

Sauvegardez le fichier et fermez gedit. 

 

Nous y sommes presque, pour certaines ROM comme la Para il ne reste plus qu'à modifier le fichier de compilation spécifique à notre Nexus :

gedit device/lge/mako/BoardConfig.mk

puis ajoutez la ligne suivant où vous voulez (pour être propre, soit tout à la fin, soit dans le 1er bloc, en dessous de "TARGET_CPU_VARIANT")

TARGET_USE_LINARO_STRING_ROUTINES := true

Sauvegardez le fichier et fermez gedit. 

 

Attention : ces 2 fichiers ayant été modifiés, ils ne seront plus synchronisés avec les sources. Pour les réactualiser il faudra soit remettre le texte précédent de façon exacte (voir §6),  soit supprimer les répertoires les contenant (commande rm -rf).

 

Voilà, vous pouvez relancer la compilation en n'oubliant pas de supprimer le répertoire "out" avant (vous voyez également comment saisir en 1 ligne 3 instruction différentes, chacune séparée par " && ") :

rm -rf ~/slim/out && . build/envsetup.sh && lunch slim_mako-userdebug && make bacon -j4

**Astuce : Pour récupérer la dernière nightly du Toolchain Linaro, reportez-vous au paragraphe 7

 

6/ Créer un batch de compilation

 

Maintenant que vous savez compiler manuellement une ROM Linaro, nous allons nous simplifier la vie en créant un batch (fichier de commandes) qui permettre en 1 commande de mettre à jour les sources, modifier si nécessaire la ligne du envsetup.sh pour Linaro (avec le programme sed) et de lancer la compilation.

 

Créons d'abord le fichier, à la racine de notre dossier personnel :

gedit ~/compilation_slim.sh

puis ajoutez les lignes de commandes suivantes dans le fichier, enregistrez le et fermez gedit :

#!/bin/bash
 
# Fonction pour compilation optimisée selon le nombre de CPU (merci à El Liberator)
# Sera utilisée à la place de make bacon -jx
function mka()
{
        schedtool -B -n0 -e ionice -c2 -n0 make -j$(cat /proc/cpuinfo | grep "^processor" | wc -l) "$@"
}
 
# suppression de la précédente compilation
rm -rf ~/slim/out
 
# Mise à jour Linaro
# Voir §7 pour plus de détail
~/get_linaro.sh
rm -rf ~/slim/prebuilts/gcc/linux-x86/arm/android-toolchain-eabi
mv ~/linaro/android-toolchain-eabi ~/slim/prebuilts/gcc/linux-x86/arm/android-toolchain-eabi
 
# On remet en ordre le fichier envsetup pour qu'il soit prit en compte par la synchro 
# Au cas où la modif de fin de batch ne se soit pas effectuée
sed -i -e "s/android-toolchain-eabi/arm-linux-androideabi-\$targetgccversion/g" ~/slim/build/envsetup.sh
 
# Synchronisation des sources
cd ~/slim
repo sync -j4
 
# Modification pour Linaro
sed -i -e "s/arm-linux-androideabi-\$targetgccversion/android-toolchain-eabi/g" ~/slim/build/envsetup.sh
 
# Environnement de compilation
. build/envsetup.sh
lunch slim_mako-userdebug
 
# Compilation avec durée (merci Minux) et fonction mka pour optimisation (merci El Libérator)
res1=$(date +%s.%N)
mka bacon
res2=$(date +%s.%N)
echo "${bldgrn}Total temps passé: ${txtrst}${grn}$(echo "($res2 - $res1) / 60"|bc ) minutes ($(echo "$res2 - $res1"|bc ) secondes) ${txtrst}"
 
# On remet en ordre le fichier envsetup pour qu'il soit prit en compte à la prochaine synchro
sed -i -e "s/android-toolchain-eabi/arm-linux-androideabi-\$targetgccversion/g" ~/slim/build/envsetup.sh

Rendons enfin le fichier exécutable :

chmod a+x ~/compilation_slim.sh

Voilà, vous pourrez lancer tout ça en saisissant simplement dans Terminal :

~/compilation_slim.sh

7/ Récupérer la dernière Nightly Linaro

 

Si vous souhaitez récupérer le tout dernier Toolchain Linaro, avec le risque que ça bug comme toute Nightly, voici comment faire.

 

Nous allons donc créer un batch qui va créer un répertoire linaro dans notre dossier personnel, télécharger la dernière version puis extraire le tout. Le script contient les commandes pour la dernière version de GCC (branche trunk) ainsi que les version 4.7 et 4.6. Si vous souhaitez une de ces 2 versions, vous pouvez décommenter les lignes correspondantes. Attention : la décompression se fait dans le même répertoire quelque soit les versions, il ne faut donc choisir qu'une seule version (je pense qu'en général on n'en prend toujours qu'une seule).

 

Créons notre fichier batch :

gedit ~/get_linaro.sh

puis copiez dedans le code suivant :

 

 

#!/bin/sh

# Emplacement du répertoire de téléchargement
DIRECTORY="$HOME/linaro"

# S'il existe déjà un répertoire Linaro, alors on le teste
if [ -d "$DIRECTORY" ]; then

# Date de modification du répertoire
modsecs=$(date --utc --reference="$DIRECTORY" +%s)

# Date actuelle
nowsecs=$(date +%s)


# Delta = différence en heures
delta=$(($nowsecs-$modsecs))
delta=$(($delta / (60 * 60)))

# On quitte si le dossier à moins de 12H, inutile de récupérer à nouveau la Nighlty
if [ $delta -lt 12 ]; then
   echo "Linaro à moins de 12H..."
   return 0
fi

# Sinon on supprime le précédent répertoire
rm -rf "$DIRECTORY"
fi

# On crée le répertoire puis on se place dedans
mkdir -p "$DIRECTORY"
cd "$DIRECTORY"

#############################
# Linaro GCC dernière version
#############################

wget --no-check-certificate https://android-build.linaro.org/jenkins/view/Toolchain/job/linaro-android_toolchain-trunk/lastSuccessfulBuild/artifact/build/out/android-toolchain-eabi-trunk-daily-linux-x86.tar.bz2

tar xf android-toolchain-eabi-trunk-daily-linux-x86.tar.bz2

################
# Linaro GCC 4.6
################

#wget --no-check-certificate https://android-build.linaro.org/jenkins/view/Toolchain/job/linaro-android_toolchain-4.6-bzr/lastSuccessfulBuild/artifact/build/out/android-toolchain-eabi-4.6-daily-linux-x86.tar.bz2

#tar xf android-toolchain-eabi-4.6-daily-linux-x86.tar.bz2

################
# Linaro GCC 4.7
################

#wget --no-check-certificate https://android-build.linaro.org/jenkins/view/Toolchain/job/linaro-android_toolchain-4.7-bzr/lastSuccessfulBuild/artifact/build/out/android-toolchain-eabi-4.7-daily-linux-x86.tar.bz2

#tar xf android-toolchain-eabi-4.7-daily-linux-x86.tar.bz2

Puis rendez ce batch exécutable :

chmod a+x ~/get_linaro.sh

Voilà, il ne vous reste plus qu'à lancer le traitement avec :

~/get_linaro.sh

Vous pouvez en profiter pour modifier le batch de compilation afin de toujours récupérer la dernière version en ajoutant au début du fichier compilation_slim.sh :

# Mise à jour Linaro
~/get_linaro.sh
rm -rf ~/slim/prebuilts/gcc/linux-x86/arm/android-toolchain-eabi
mv ~/linaro/android-toolchain-eabi ~/slim/prebuilts/gcc/linux-x86/arm/android-toolchain-eabi[size=4]
[/size]

8/ Divers

 

Pour la ROM PSX, vous pouvez compiler le Kernel PSX en même temps (merci à Mikosims d'avoir cherché), il faut lancer un "build-kernel.sh" entre les commandes "lunch psx_mako-user" et "make" :

# Compilation du Kernel
cd ~/psx/kernel/lge/mako/
. build-kernel.sh
wait
cd ~/psx

Modifié 21 juillet 2014 par Okaryn

[Okaryn]

Modifications :
 

21/12/2013 :

• Ajout du §8 Divers, avec l'astuce pour compiler le Kernel PSX en même temps que le ROM du même nom

09/11/2013 :

• Modification pour ccache afin qu'il ne soit pas lié au dossier la ROM mais au système (ajout dans apt-get)
• Modification du script de récupération Linaro pour qu'il ne travaille qu'une fois par 24H (si on compile plusieurs fois par jour, ça fait gagner du temps)

25/10/2013 :

• Prise en compte du message d'El Liberator pour l'optimisation de la compilation (voir script et fonction mka)

24/10/2013 :

• Prise en compte du message de El Liberator sur la sync des fichiers modifiés par retour arrière des modifications
• Prise en compte du message de Minux sur l'init du repo et la sync des fichiers modifiés

23/10/2013 : 

• Ajout §7 pour récupérer la Nightly Linaro

21/10/2013 : 

• Modification du batch pour durée de compilation (par Minux) + oubli de la 1ère ligne + ajouts commentaires

20/10/2013 : 

• Création d'un batch d'automatisation pour la compilation
• Correction d'une erreur dans la partie Linaro sur la chaine à remplacer (toolchaindir=arm/android-toolchain-eabi/bin)
• Ajout du paramétrage du cache et de sa visualisation
• Ajout activation du cache de compilation
• Ajout compilation Linaro
• Version initiale

 

Modifié 21 décembre 2013 par Okaryn

[NeB]

Très intéressant !!

Merci beaucoup pour ce boulot !

Va falloir que je me fasse un dual boot Win/Ubuntu pour essayer ^^ (j'ai un i3 donc en VM ça risque d'être limite)

 

Je me permet juste une petite remarque (ou plutôt une question) :

ici http://forum.slimroms.net/topic/155-request-for-a-guide-to-compile-your-own-build-of-slimbean/#entry837

un des devs de SlimBean précise l'histoire du "-jX" et lui parle de nombre de coeurs + 1 au lieu de nombre de coeurs * 2

Quelle est donc la bonne valeur à utiliser ?

 

EDIT: je me suis permis de mettre le lien vers ton tuto dans le sujet du forum Slimroms, au cas où quelqu'un se sentirait de le traduire, puisque c'est une demande, un tuto en anglais pour compiler Slimbean.

Modifié 20 octobre 2013 par NeB

[Okaryn]

La valeur pour le -J est entre 1 et 2 fois le nombre de threads si on se réfère à la documentation de Google : 

 

Build everything with make. GNU make can handle parallel tasks with a -jN argument, and it's common to use a number of tasks N that's between 1 and 2 times the number of hardware threads on the computer being used for the build. E.g. on a dual-E5520 machine (2 CPUs, 4 cores per CPU, 2 threads per core), the fastest builds are made with commands between make -j16 and make -j32.

 

Dans l'exemple, on à 2 processeurs E5520, chacun avec 4 coeurs de 2 threads, donc 2 * 4 * 2 = 16 pour la valeur minimum et jusqu'à 32 pour le maximum.

 

Je vais être plus précis dans le tutoriel.

 

Pas de soucis pour le lien, autant partager un maximum. J'ai moi même repiqué les infos sur pleins de forums différents, chacun avec des choses plus ou moins complètes.

Modifié 20 octobre 2013 par Okaryn

[julz]

Super boulot. vraiment ! Depuis le temps que je me coltine des tutos en anglais, ça fait vraiment plaisir.  :)

 

Merci Okaryn !

 

Des que j'ai mon nouveau pc, je test (mais c'est pas pour tout de suite).

[Burn2]

Merci vraiment pour ce tuto!!!!

 

Petite question, pour compiler en user_debug? C'est nécessaire? 

 

 

Autre point que j'aimerais bien voir abordé, c'est comment changer le kernel, genre inclure de base le kernel semaphore. :)

 

 

Mais en tous cas merci beaucoup pour ce tutoriel! :)

[Okaryn]

Le mode user_debug permet d'avoir l'accès root et ajoute des options de debugage utiles à certaines app (voir sur le lien de la doc Google).

 

Pour la deuxième partie et personnaliser sa custom rom, je te renvoi sur un ancien tutoriel que j'avais réalisé. Ca date de plus de 2 ans, mais le principe reste valable :p

Modifié 22 octobre 2013 par Okaryn

[Minux]

Cette méthode permet d'inclure un kernel à postériori dans un zip de rom déjà compilée, ce que j'ai recherché à faire à de nombreuses reprises c'est comment intégrer les sources d'un kernel extérieur dans une rom pour le compiler avec la rom, mais ça j'ai jamais réussi à le faire ... donc si vous avez des pistes (j'aimerais inclure le Semaphore dont les sources sont disponibles à ma build de Slim), je suis preneur :)

Modifié 22 octobre 2013 par Minux

[julz]

Je plussoie.

 

Quitte à se lancer également dans la compilation, autant le faire complètement  :P

[Minux]

C'est ma philo de conception de rom, ne toucher à rien une fois le zip créé :D

[julz]

Je te rejoins.  ^_^

 

Vivement mon nouveau PC  :mellow:

[Okaryn]

Je viens d'ajouter le §7 pour récupérer la Nightly Linaro et je profite de la mise à jour des sources pour tester ;)

 

Pour ajouter un autre Kernel ça ne doit pas être simple... Je pense qu'il faut se créer son propre repo sera un fork de ROM et du Kernel souhaité.

Modifié 23 octobre 2013 par Okaryn

[julz]

Sympa ça. Petite question : les commandes sont les mêmes selon les versions linux?

Sinon je veux bien tester ta compilation :-)

Merci pour ce que tu fais. ;-)

Envoyé de mon Nexus 4 en utilisant Tapatalk

[Okaryn]

Ca fonctionne sur (presque) n'importe quelle version basée sur Ubuntu, pour les autres il faudra peut être modifier la 1ère partie (apt-get n'existera peut être pas) et la commande "sudo" qui peut s'appeler autrement.

 

J'ai marqué presque, car je n'ai testé que 3 versions d'ubuntu + 2 versions de Mint ;)

 

Je télécharge mon Zip sur Mega, je reviens mettre le lien d'ici 15 minutes. Voila le lien : https://mega.co.nz/#!6JAiSbjb!MitslA4sMA2Zen1NOqPiuytVfiF_Nngh50qwDlz0G7w

Modifié 23 octobre 2013 par Okaryn

[julz]

Ok merci pour l'info. C'était pour ma culture perso.

 

Et merci pour le lien. Je prends.  :)

[Minux]

ça peut se faire sur n'importe quelle distrib (perso je tourne sur Archlinux depuis quelques années), après faut adapter les commandes comme l'as dit OKARYN, mais surtout faut avoir les bonnes versions d'outils (exemple python est en version 3 par défaut sur ma distrib, donc il a fallut que j'installe la version 2 et faire en sorte que la compil utilise la version 2 et pas la 3, idem pour make qui est en 4, alors que la version doit être 3.81 ou 3.82).

 

Bref, ça s'adapte à toutes distrib au final, faut juste vérifier les pré-requis de compilation d'android donnés ici : http://source.android.com/source/initializing.html

 

• Python 2.6 -- 2.7, which you can download from python.org.

• GNU Make 3.81 -- 3.82, which you can download from gnu.org,
• JDK 6 if you wish to build Gingerbread or newer; JDK 5 for Froyo or older. You can download both fromjava.sun.com.
• Git 1.7 or newer. You can find it at git-scm.com.

 

Modifié 23 octobre 2013 par Minux

[Okaryn]

Merci Minux :) J'ai fait un lien dans le tuto sur ton message pour ceux qui utiliseraient une autre distribution

 

@Julz : mise à jour de la ROM suite à des modifs sur la gestion du dalvik-cache (nan je ne deviens pas accro à la compilation), c'est ici : https://mega.co.nz/#!6JAiSbjb!MitslA4sMA2Zen1NOqPiuytVfiF_Nngh50qwDlz0G7w

Modifié 23 octobre 2013 par Okaryn

[julz]

Merci Okaryn. Je chope tout ça.

Merci pour ton boulot.

Envoyé de mon Nexus 4 en utilisant Tapatalk

Bouh le lien il est mort.... :-(

Envoyé de mon Nexus 4 en utilisant Tapatalk

[Okaryn]

Bouh le lien il est mort.... :-(

 

Je viens de tester, c'est ok pour moi, tu as bien utilisé  ce lien ?

Modifié 23 octobre 2013 par Okaryn

[julz]

Oui oui :

Envoyé de mon Nexus 4 en utilisant Tapatalk

Non c'est ok. Avec l'appli Méga ça fonctionne...

Envoyé de mon Nexus 4 en utilisant Tapatalk

[Okaryn]

Il me semble que Mega limite le nombre de téléchargements simultanés quand on a pas de compte pro et c'est pour ça qu'il y a ces messages d'erreurs parfois.

[julz]

Peut-être. En tout cas je suis sur ton build. Rien a redire. :-)

Envoyé de mon Nexus 4 en utilisant Tapatalk

[Minux]

Juste quelques remarque sur le script de compilation :

 

- Pourquoi tu refais un "repo init -u git:/ /github.com/SlimRoms/platform_manifest.git -b jb4.3" à chaque compil ?

Cette chaîne ne sert qu'à initialiser le repo en local, donc une fois que tu l'as fait la première fois pour récupérer les sources, tu te met dans le répertoire et un "repo sync -jX" suffit à rafraichir les sources pour les fois suivantes. Cette ligne est donc inutile.

 

- De plus, si jamais le fichier build/envsetup.sh est modfié au niveau sources, comme tu l'as modifié les fois d'avant avec sed pour y placer la toolchain linaro, tu aura une erreur lors du sync, et la nouvelle version du fichier ne sera pas récupérée. Je te conseil donc de supprimer le répertoire build avant le repo sync avec un rm -Rf (j'ai testé, la suppression du fichier seul ne fonctionne pas, il ne récupère pas le fichier lors du sync), de manière à être sur de récupérer la dernière version.

 

Voilà, c'est tout , merci en tout cas pour ce super tuto qui est très utile :)

[Okaryn]

Merci beaucoup Minux pour ces conseils :)

 

Je pensais que le repo devait être réinitialisé si on travaillait sur plusieurs ROM, je n'avais pas fait attention qu'il y avait un dossier .repo caché avec ce qu'il fallait dedans.

[el liberator]

ou alors remettre à l'état d'origine avant de lancer le : repo sync

comme ceci :

sed -i 's/android-toolchain-eabi/arm-linux-androideabi-\$targetgccversion/' chemin_vers_le fichier/envsetup.sh

 

moi en fait je me suis fais un script qui fait tout

-remet en état d'orgine

-repo sync

-envsetup

-lunch

-ajout de certaines choses selon les arguments passés au script

-compilation

-réajout d'autres trucs selon les arguments passé au script

-zip de la ROM

Modifié 24 octobre 2013 par el liberator